using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Web;
using System.Web.Mvc;
using ChadSoft.UI;

namespace ChadSoft.Web.Mvc
{
    public static class UIExtensions
    {
        #region Base Paths

        private static readonly string STATIC_CONTENT_BASE_PATH =
            Parse.AppSetting<string>("StaticContent.BasePath") ?? "/content";
        private static readonly string IMAGES_BASE_PATH = string.Format("{0}/images", STATIC_CONTENT_BASE_PATH);
        private static readonly string CSS_STYLES_BASE_PATH =
            Parse.AppSetting<string>("Stylesheets.BasePath") ?? "/styles";

        #endregion

        /// <summary>
        /// Creates a formatted list of items based on the passed in format
        /// </summary>
        public static string ToFormattedList(this IEnumerable list, UIListType listType)
        {
            string outerListFormat = "";
            string listFormat = "";

            switch (listType)
            {
                case UIListType.Ordered:
                    outerListFormat = "<ol>{0}</ol>";
                    listFormat = "<li>{0}</li>";
                    break;
                case UIListType.Unordered:
                    outerListFormat = "<ul>{0}</ul>";
                    listFormat = "<li>{0}</li>";
                    break;
                case UIListType.TableCell:
                    outerListFormat = "{0}";
                    listFormat = "<td>{0}</td>";
                    break;
                default:
                    break;
            }

            return string.Format(outerListFormat, ForEach(list, listFormat));
        }

        #region ForEach

        /// <summary>
        /// Iterates through an enumerable applying the format string to each line. 
        /// </summary>
        /// <param name="enumerable">The enumeration to apply the function to</param>
        /// <param name="format">The format string to apply against each enumerated object</param>
        /// <returns>The aggregated markup emitted by formatted output of all the enumerated objects.</returns>
        public static string ForEach(this IEnumerable enumerable, string format)
        {
            return ForEach(enumerable as IEnumerable<object>, (o => string.Format(format, o)));
        }
        /// <summary>
        /// Iterates through an enumerable applying the format string to each line. 
        /// </summary>
        /// <param name="enumerable">The enumeration to apply the function to</param>
        /// <param name="outerFormat">The format string to wrap the result of the inner items</param>
        /// <param name="format">The format string to apply against each enumerated object</param>
        /// <returns>The aggregated markup emitted by formatted output of all the enumerated objects.</returns>
        public static string ForEach(this IEnumerable enumerable, string outerFormat, string format)
        {
            return ForEach(enumerable as IEnumerable<object>, outerFormat, (o => string.Format(format, o)));
        }

        #endregion

        #region ForEach<T>

        /// <summary>
        /// Iterates through an enumerable adding the result of the function for each line. 
        /// </summary>
        /// <typeparam name="T">Type of object to be used in the function</typeparam>
        /// <param name="enumerable">The enumeration to which the function will be applied</param>
        /// <param name="function">The function to apply to each enumerated object</param>
        /// <returns>The aggregated markup emitted by the function calls against all of the enumerated objects.</returns>
        public static string ForEach<T>(this IEnumerable<T> enumerable, Func<T,string> function)
        {
            return ForEach(enumerable, "{0}", function);
        }
        /// <summary>
        /// Iterates through an enumerable adding the result of the function for each line. 
        /// </summary>
        /// <typeparam name="T">Type of object to be used in the function</typeparam>
        /// <param name="enumerable">The enumeration to which the function will be applied</param>
        /// <param name="outerFormat">The format string to wrap the result of the inner items</param>
        /// <param name="function">The function to apply to each enumerated object</param>
        /// <returns>The aggregated markup emitted by the function calls against all of the enumerated objects.</returns>
        public static string ForEach<T>(this IEnumerable<T> enumerable, string outerFormat, Func<T,string> function)
        {
            var markup = new StringBuilder();
            
            foreach (var val in enumerable)
                markup.AppendLine(function(val));
            
            return string.Format(outerFormat, markup);
        }

        #endregion


        public static string Stylesheet(this UrlHelper urlHelper, string stylesheet)
        {
            var url = string.Format("{0}/{1}", CSS_STYLES_BASE_PATH, CleanRelativePath(stylesheet));
            return string.Format("<link href='{0}' rel='stylesheet' type='text/css' />", url);
        }

        public static string ImageLink(this HtmlHelper html, string linkUrl, string imageUrl, string title, bool externalLink)
        {
            var cleanImageUrl = string.Format("{0}/{1}", IMAGES_BASE_PATH, CleanRelativePath(imageUrl));
            var htmlAttibutes = externalLink ? "target='_blank'" : string.Empty;

            return string.Format("<a href='{0}' title='{1}' {3}><img src='{2}' alt='{1}' border='0' /></a>",
                                 linkUrl, title, cleanImageUrl, htmlAttibutes);
        }

        /// <summary>
        /// Take a path and clean it up (if relative, make it absolute; remove trailing slash, etc.)
        /// </summary>
        /// <param name="path">the path to clean</param>
        /// <returns>The cleaned-up path</returns>
        private static string CleanRelativePath(string path)
        {
            var cleanPath = path;

            // Clean up the URL if it's not empty or absolute
            if (!string.IsNullOrEmpty(cleanPath) && !cleanPath.StartsWith("http:", StringComparison.OrdinalIgnoreCase))
            {
                // Clean up the path first
                if(cleanPath.StartsWith("~/", StringComparison.OrdinalIgnoreCase))
                    cleanPath = VirtualPathUtility.ToAbsolute(cleanPath);
                else if(cleanPath.StartsWith("/", StringComparison.OrdinalIgnoreCase))
                    cleanPath = cleanPath.Substring(1, cleanPath.Length - 1);
            }

            return cleanPath;
        }

    }
}