ViewUtils.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading;
using ServiceStack.Configuration;
using ServiceStack.IO;
using ServiceStack.Script;
using ServiceStack.Text;
using ServiceStack.Web;

namespace ServiceStack
{
    /// <summary>
    /// High-level Input options for rendering HTML Input controls
    /// </summary>
    public class InputOptions
    {
        /// <summary>
        /// Display the Control inline 
        /// </summary>
        public bool Inline { get; set; }
        
        /// <summary>
        /// Label for the control
        /// </summary>
        public string Label { get; set; }
        
        /// <summary>
        /// Class for Label
        /// </summary>
        public string LabelClass { get; set; }
        
        /// <summary>
        /// Override the class on the error message (default: invalid-feedback)
        /// </summary>
        public string ErrorClass { get; set; }

        /// <summary>
        /// Small Help Text displayed with the control
        /// </summary>
        public string Help { get; set; }
        
        /// <summary>
        /// Bootstrap Size of the Control: sm, lg
        /// </summary>
        public string Size { get; set; }
        
        /// <summary>
        /// Multiple Value Data Source for Checkboxes, Radio boxes and Select Controls 
        /// </summary>
        public object Values { get; set; }

        /// <summary>
        /// Typed setter of Multi Input Values
        /// </summary>
        public IEnumerable<KeyValuePair<string, string>> InputValues
        {
            set => Values = value;
        }

        /// <summary>
        /// Whether to preserve value state after post back
        /// </summary>
        public bool PreserveValue { get; set; } = true;

        /// <summary>
        /// Whether to show Error Message associated with this control
        /// </summary>
        public bool ShowErrors { get; set; } = true;
    }

    /// <summary>
    /// Customize JS/CSS/HTML bundles
    /// </summary>
    public class BundleOptions
    {
        /// <summary>
        /// List of file and directory sources to include in this bundle, directory sources must end in `/`.
        /// Sources can include prefixes to specify which Virtual File System Source to use, options:
        /// 'content:' (ContentRoot HostContext.VirtualFiles), 'filesystem:' (WebRoot FileSystem), 'memory:' (WebRoot Memory)
        /// </summary>
        public List<string> Sources { get; set; } = new List<string>();
        
        /// <summary>
        /// Write bundled file to this Virtual Path
        /// </summary>
        public string OutputTo { get; set; }
        /// <summary>
        /// If needed, use alternative OutputTo Virtual Path in html tag
        /// </summary>
        public string OutputWebPath { get; set; }
        /// <summary>
        /// If needed, include PathBase prefix in output tag
        /// </summary>
        public string PathBase { get; set; }
        /// <summary>
        /// Whether to minify sources in bundle (default true)
        /// </summary>
        public bool Minify { get; set; } = true;
        /// <summary>
        /// Whether to save to disk or Memory File System (default Memory)
        /// </summary>
        public bool SaveToDisk { get; set; }
        /// <summary>
        /// Whether to return cached bundle if exists (default true)
        /// </summary>
        public bool Cache { get; set; } = true;
        /// <summary>
        /// Whether to bundle and emit single or not bundle and emit multiple html tags
        /// </summary>
        public bool Bundle { get; set; } = true;
        /// <summary>
        /// Whether to call AMD define for CommonJS modules
        /// </summary>
        public bool RegisterModuleInAmd { get; set; }
        /// <summary>
        /// Whether to wrap JS scripts in an Immediately-Invoked Function Expression
        /// </summary>
        public bool IIFE { get; set; }
    }

    public class TextDumpOptions
    {
        public TextStyle HeaderStyle { get; set; }
        public string Caption { get; set; }
        public string CaptionIfEmpty { get; set; }
        
        public string[] Headers { get; set; }
        public bool IncludeRowNumbers { get; set; } = true;

        public DefaultScripts Defaults { get; set; } = ViewUtils.DefaultScripts;
        
        internal int Depth { get; set; }
        internal bool HasCaption { get; set; }

        public static TextDumpOptions Parse(Dictionary<string, object> options, DefaultScripts defaults=null)
        {
            return new() {
                HeaderStyle = options.TryGetValue("headerStyle", out var oHeaderStyle)
                    ? oHeaderStyle.ConvertTo<TextStyle>()
                    : TextStyle.SplitCase,
                Caption = options.TryGetValue("caption", out var caption)
                    ? caption?.ToString()
                    : null,
                CaptionIfEmpty = options.TryGetValue("captionIfEmpty", out var captionIfEmpty)
                    ? captionIfEmpty?.ToString()
                    : null,
                IncludeRowNumbers = !options.TryGetValue("rowNumbers", out var rowNumbers) 
                    || (rowNumbers is not bool b || b),
                Defaults = defaults ?? ViewUtils.DefaultScripts,
            };
        }
    }

    public class HtmlDumpOptions
    {
        public string Id { get; set; }
        public string ClassName { get; set; }
        public string ChildClass { get; set; }

        public TextStyle HeaderStyle { get; set; }
        public string HeaderTag { get; set; }
        
        public string Caption { get; set; }
        public string CaptionIfEmpty { get; set; }
        
        public string[] Headers { get; set; }

        public DefaultScripts Defaults { get; set; } = ViewUtils.DefaultScripts;
        
        public string Display { get; set; }
        internal int Depth { get; set; }
        internal int ChildDepth { get; set; } = 1;
        internal bool HasCaption { get; set; }
        
        public static HtmlDumpOptions Parse(Dictionary<string, object> options, DefaultScripts defaults=null)
        {
            return new HtmlDumpOptions 
            {
                Id = options.TryGetValue("id", out var oId)
                    ? (string)oId
                    : null,
                ClassName = options.TryGetValue("className", out var oClassName)
                    ? (string)oClassName
                    : null,
                ChildClass = options.TryGetValue("childClass", out var oChildClass)
                    ? (string)oChildClass
                    : null,

                HeaderStyle = options.TryGetValue("headerStyle", out var oHeaderStyle)
                    ? oHeaderStyle.ConvertTo<TextStyle>()
                    : TextStyle.SplitCase,
                HeaderTag = options.TryGetValue("headerTag", out var oHeaderTag)
                    ? (string)oHeaderTag
                    : null,
                
                Caption = options.TryGetValue("caption", out var caption)
                    ? caption?.ToString()
                    : null,
                CaptionIfEmpty = options.TryGetValue("captionIfEmpty", out var captionIfEmpty)
                    ? captionIfEmpty?.ToString()
                    : null,
                Display = options.TryGetValue("display", out var display)
                    ? display?.ToString()
                    : null,
                Defaults = defaults ?? ViewUtils.DefaultScripts,
            };
        }
    }

    public enum TextStyle
    {
        None,
        SplitCase,
        Humanize,
        TitleCase,
        PascalCase,
        CamelCase,
    }
    
    /// <summary>
    /// Generic collection of Nav Links
    /// </summary>
    public static class NavDefaults
    {
        public static string NavClass { get; set; } = "nav";
        public static string NavItemClass { get; set; } = "nav-item";
        public static string NavLinkClass { get; set; } = "nav-link";
        
        public static string ChildNavItemClass { get; set; } = "nav-item dropdown";
        public static string ChildNavLinkClass { get; set; } = "nav-link dropdown-toggle";
        public static string ChildNavMenuClass { get; set; } = "dropdown-menu";
        public static string ChildNavMenuItemClass { get; set; } = "dropdown-item";
        
        public static NavOptions Create() => new NavOptions {
            NavClass = NavClass,
            NavItemClass = NavItemClass,
            NavLinkClass = NavLinkClass,
            ChildNavItemClass = ChildNavItemClass,
            ChildNavLinkClass = ChildNavLinkClass,
            ChildNavMenuClass = ChildNavMenuClass,
            ChildNavMenuItemClass = ChildNavMenuItemClass,
        };
        public static NavOptions ForNav(this NavOptions options) => options; //Already uses NavDefaults
        public static NavOptions OverrideDefaults(NavOptions targets, NavOptions source)
        {
            if (targets == null)
                return source;
            if (targets.NavClass == NavClass && source.NavClass != null)
                targets.NavClass = source.NavClass;
            if (targets.NavItemClass == NavItemClass && source.NavItemClass != null)
                targets.NavItemClass = source.NavItemClass;
            if (targets.NavLinkClass == NavLinkClass && source.NavLinkClass != null)
                targets.NavLinkClass = source.NavLinkClass;
            if (targets.ChildNavItemClass == ChildNavItemClass && source.ChildNavItemClass != null)
                targets.ChildNavItemClass = source.ChildNavItemClass;
            if (targets.ChildNavLinkClass == ChildNavLinkClass && source.ChildNavLinkClass != null)
                targets.ChildNavLinkClass = source.ChildNavLinkClass;
            if (targets.ChildNavMenuClass == ChildNavMenuClass && source.ChildNavMenuClass != null)
                targets.ChildNavMenuClass = source.ChildNavMenuClass;
            if (targets.ChildNavMenuItemClass == ChildNavMenuItemClass && source.ChildNavMenuItemClass != null)
                targets.ChildNavMenuItemClass = source.ChildNavMenuItemClass;
            return targets;
        }
    }
    /// <summary>
    /// Single NavLink List Item
    /// </summary>
    public static class NavLinkDefaults
    {
        public static NavOptions ForNavLink(this NavOptions options) => options; //Already uses NavDefaults
    }
    /// <summary>
    /// Navigation Bar Menu Items
    /// </summary>
    public static class NavbarDefaults
    {
        public static string NavClass { get; set; } = "navbar-nav";
        public static NavOptions Create() => new NavOptions { NavClass = NavClass };
        public static NavOptions ForNavbar(this NavOptions options) => NavDefaults.OverrideDefaults(options, Create());
    }
    /// <summary>
    /// Collection of Link Buttons (e.g. used to render /auth buttons)
    /// </summary>
    public static class NavButtonGroupDefaults
    {
        public static string NavClass { get; set; } = "btn-group";
        public static string NavItemClass { get; set; } = "btn btn-primary";
        public static NavOptions Create() => new NavOptions { NavClass = NavClass, NavItemClass = NavItemClass };
        public static NavOptions ForNavButtonGroup(this NavOptions options) => NavDefaults.OverrideDefaults(options, Create());
    }
    
    public class NavOptions
    {
        /// <summary>
        /// User Attributes for conditional rendering, e.g:
        ///  - auth - User is Authenticated
        ///  - role:name - User Role
        ///  - perm:name - User Permission 
        /// </summary>
        public HashSet<string> Attributes { get; set; }
        
        /// <summary>
        /// Path Info that should set as active 
        /// </summary>
        public string ActivePath { get; set; }
        
        
        /// <summary>
        /// Prefix to include before NavItem.Path (if any)
        /// </summary>
        public string BaseHref { get; set; }

        /// <summary>
        /// Custom classes applied to different navigation elements (defaults to Bootstrap classes)
        /// </summary>
        public string NavClass { get; set; } = NavDefaults.NavClass;
        public string NavItemClass { get; set; } = NavDefaults.NavItemClass;
        public string NavLinkClass { get; set; } = NavDefaults.NavLinkClass;
        
        public string ChildNavItemClass { get; set; } = NavDefaults.ChildNavItemClass;
        public string ChildNavLinkClass { get; set; } = NavDefaults.ChildNavLinkClass;
        public string ChildNavMenuClass { get; set; } = NavDefaults.ChildNavMenuClass;
        public string ChildNavMenuItemClass { get; set; } = NavDefaults.ChildNavMenuItemClass;
    }

    /// <summary>
    /// Public API for ViewUtils
    /// </summary>
    public static class View
    {
        public static List<NavItem> NavItems => ViewUtils.NavItems;
        public static Dictionary<string, List<NavItem>> NavItemsMap => ViewUtils.NavItemsMap;
        public static void Load(IAppSettings settings) => ViewUtils.Load(settings);

        public static List<NavItem> GetNavItems(string key) => ViewUtils.GetNavItems(key);
    }

    /// <summary>
    /// Shared Utils shared between different Template Filters and Razor Views/Helpers
    /// </summary>
    public static class ViewUtils
    {
        internal static readonly DefaultScripts DefaultScripts = new() { Context = new ScriptContext() };
        private static readonly HtmlScripts HtmlScripts = new() { Context = new ScriptContext() };

        public static string NavItemsKey { get; set; } = "NavItems";
        public static string NavItemsMapKey { get; set; } = "NavItemsMap";
        
        public static void Load(IAppSettings settings)
        {
            var navItems = settings?.Get<List<NavItem>>(NavItemsKey);
            if (navItems != null)
            {
                NavItems.AddRange(navItems);
            }

            var navItemsMap = settings?.Get<Dictionary<string, List<NavItem>>>(NavItemsMapKey);
            if (navItemsMap != null)
            {
                foreach (var entry in navItemsMap)
                {
                    NavItemsMap[entry.Key] = entry.Value;
                }
            }
        }

        public static bool ShowNav(this NavItem navItem, HashSet<string> attributes)
        {
            if (attributes.IsEmpty())
                return navItem.Show == null;
            if (navItem.Show != null && !attributes.Contains(navItem.Show))
                return false;
            if (navItem.Hide != null && attributes.Contains(navItem.Hide))
                return false;
            return true;
        }

        public static List<NavItem> NavItems { get; } = new();
        public static Dictionary<string, List<NavItem>> NavItemsMap { get; } = new();

        public static List<NavItem> GetNavItems(string key) => NavItemsMap.TryGetValue(key, out var navItems)
            ? navItems
            : TypeConstants<NavItem>.EmptyList;

        public static string CssIncludes(IVirtualPathProvider vfs, List<string> cssFiles)
        {
            if (vfs == null || cssFiles == null || cssFiles.Count == 0)
                return null;
            
            
            var sb = StringBuilderCache.Allocate();
            sb.AppendLine("<style>");

            foreach (var cssFile in cssFiles)
            {
                var virtualPath = !cssFile.StartsWith("/")
                    ? "/css/" + cssFile + ".css"
                    : cssFile;
                
                var file = vfs.GetFile(virtualPath.TrimStart('/'));
                if (file == null)
                    continue;

                string line;
                using var reader = file.OpenText();
                while ((line = reader.ReadLine()) != null)
                {
                    sb.AppendLine(line);
                }
            }
            
            sb.AppendLine("</style>");
            return StringBuilderCache.ReturnAndFree(sb);
        }
        
        public static string JsIncludes(IVirtualPathProvider vfs, List<string> jsFiles)
        {
            if (vfs == null || jsFiles == null || jsFiles.Count == 0)
                return null;
            
            
            var sb = StringBuilderCache.Allocate();
            sb.AppendLine("<script>");

            foreach (var jsFile in jsFiles)
            {
                var virtualPath = !jsFile.StartsWith("/")
                    ? "/js/" + jsFile + ".js"
                    : jsFile;
                
                var file = vfs.GetFile(virtualPath.TrimStart('/'));
                if (file == null)
                    continue;

                string line;
                using var reader = file.OpenText();
                while ((line = reader.ReadLine()) != null)
                {
                    sb.AppendLine(line);
                }
            }
            
            sb.AppendLine("</script>");
            return StringBuilderCache.ReturnAndFree(sb);
        }
        
        /// <summary>
        ///  Display a list of NavItem's
        /// </summary>
        public static string Nav(List<NavItem> navItems, NavOptions options)
        {
            if (navItems.IsEmpty())
                return string.Empty;
            
            var sb = StringBuilderCache.Allocate();
            sb.Append("<div class=\"")
                .Append(options.NavClass)
                .AppendLine("\">");

            foreach (var navItem in navItems)
            {
                NavLink(sb, navItem, options);
            }

            sb.AppendLine("</div>");
            return sb.ToString();
        }

        /// <summary>
        /// Display a `nav-link` nav-item
        /// </summary>
        public static string NavLink(NavItem navItem, NavOptions options)
        {
            var sb = StringBuilderCache.Allocate();
            NavLink(sb, navItem, options);
            return StringBuilderCache.ReturnAndFree(sb);
        }

        static string ActiveClass(NavItem navItem, string activePath) => 
            navItem.Href != null && (navItem.Exact == true || activePath.Length <= 1 
                ? activePath?.TrimEnd('/').EqualsIgnoreCase(navItem.Href?.TrimEnd('/')) == true
                : activePath.TrimEnd('/').StartsWithIgnoreCase(navItem.Href?.TrimEnd('/')))
                    ? " active"
                    : "";
        
        /// <summary>
        /// Display a `nav-link` nav-item
        /// </summary>
        public static void NavLink(StringBuilder sb, NavItem navItem, NavOptions options)
        {
            if (!navItem.ShowNav(options.Attributes))
                return;
            
            var hasChildren = navItem.Children?.Count > 0;
            var navItemCls = hasChildren
                ? options.ChildNavItemClass
                : options.NavItemClass;
            var navLinkCls = hasChildren
                ? options.ChildNavLinkClass
                : options.NavLinkClass;
            var id = navItem.Id;
            if (hasChildren && id == null)
                id = navItem.Label.SafeVarName() + "MenuLink";

            sb.Append("<li class=\"")
                .Append(navItem.ClassName).Append(navItem.ClassName != null ? " " : "")
                .Append(navItemCls)
                .AppendLine("\">");
                
            sb.Append("  <a href=\"")
                .Append(options.BaseHref?.TrimEnd('/'))
                .Append(navItem.Href)
                .Append("\"");

            sb.Append(" class=\"")
                .Append(navLinkCls).Append(ActiveClass(navItem,options.ActivePath))
                .Append("\"");

            if (id != null)
                sb.Append(" id=\"").Append(id).Append("\"");

            if (hasChildren)
            {
                sb.Append(" role=\"button\" data-toggle=\"dropdown\" aria-haspopup=\"true\" aria-expanded=\"false\"");
            }
            
            sb.Append(">")
                .Append(navItem.Label)
                .AppendLine("</a>");

            if (hasChildren)
            {
                sb.Append("  <div class=\"")
                    .Append(options.ChildNavMenuClass)
                    .Append("\" aria-labelledby=\"").Append(id).AppendLine("\">");

                foreach (var childNav in navItem.Children)
                {
                    if (childNav.Label == "-")
                    {
                        sb.AppendLine("    <div class=\"dropdown-divider\"></div>");
                    }
                    else
                    {
                        sb.Append("    <a class=\"")
                            .Append(options.ChildNavMenuItemClass)
                            .Append(ActiveClass(childNav,options.ActivePath))
                            .Append("\"")
                            .Append(" href=\"")
                            .Append(options.BaseHref?.TrimEnd('/'))
                            .Append(childNav.Href)
                            .Append("\">")
                            .Append(childNav.Label)
                            .AppendLine("</a>");
                    }
                }
                sb.AppendLine("</div");
            }

            sb.Append("</lI>");
        }

        public static string NavButtonGroup(List<NavItem> navItems, NavOptions options)
        {
            if (navItems.IsEmpty())
                return string.Empty;
            
            var sb = StringBuilderCache.Allocate();
            sb.Append("<div class=\"")
                .Append(options.NavClass)
                .AppendLine("\">");

            foreach (var navItem in navItems)
            {
                NavLinkButton(sb, navItem, options);
            }

            sb.AppendLine("</div>");
            return sb.ToString();
        }

        public static string NavButtonGroup(NavItem navItem, NavOptions options)
        {
            var sb = StringBuilderCache.Allocate();
            NavLinkButton(sb, navItem, options);
            return StringBuilderCache.ReturnAndFree(sb);
        }
        
        public static void NavLinkButton(StringBuilder sb, NavItem navItem, NavOptions options)
        {
            if (!navItem.ShowNav(options.Attributes))
                return;
            
            sb.Append("<a href=\"")
                .Append(options.BaseHref?.TrimEnd('/'))
                .Append(navItem.Href)
                .Append("\"");

            sb.Append(" class=\"")
                .Append(navItem.ClassName).Append(navItem.ClassName != null ? " " : "")
                .Append(options.NavItemClass).Append(ActiveClass(navItem, options.ActivePath))
                .Append("\"");

            if (navItem.Id != null)
                sb.Append(" id=\"").Append(navItem.Id).Append("\"");

            sb.Append(">")
                .Append(!string.IsNullOrEmpty(navItem.IconClass) 
                    ? $"<i class=\"{navItem.IconClass}\"></i>" : "")
                .Append(navItem.Label)
                .AppendLine("</a>");
        }
        

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool IsNull(object test) => test == null || test == JsNull.Value;
        
        public static CultureInfo GetDefaultCulture(this DefaultScripts defaultScripts) => 
            defaultScripts?.Context?.Args[ScriptConstants.DefaultCulture] as CultureInfo ?? ScriptConfig.DefaultCulture;
        
        public static string GetDefaultTableClassName(this DefaultScripts defaultScripts) => 
            defaultScripts?.Context?.Args[ScriptConstants.DefaultTableClassName] as string;

        public static string TextDump(this object target) => DefaultScripts.TextDump(target, null); 
        public static string TextDump(this object target, TextDumpOptions options) => DefaultScripts.TextDump(target, options); 
        public static string DumpTable(this object target) => DefaultScripts.TextDump(target, null); 
        public static void PrintDumpTable(this object target) => DumpTable(target).Print(); 
        public static string DumpTable(this object target, TextDumpOptions options) => DefaultScripts.TextDump(target, options);
        public static void PrintDumpTable(this object target, TextDumpOptions options) => DumpTable(target, options).Print(); 
        
        public static string HtmlDump(object target) => HtmlScripts.HtmlDump(target, null); 
        public static string HtmlDump(object target, HtmlDumpOptions options) => HtmlScripts.HtmlDump(target, options); 
        
        public static string StyleText(string text, TextStyle textStyle)
        {
            if (text == null) return null;
            switch (textStyle)
            {
                case TextStyle.SplitCase:
                    return DefaultScripts.splitCase(text);
                case TextStyle.Humanize:
                    return DefaultScripts.humanize(text);
                case TextStyle.TitleCase:
                    return DefaultScripts.titleCase(text);
                case TextStyle.PascalCase:
                    return DefaultScripts.pascalCase(text);
                case TextStyle.CamelCase:
                    return DefaultScripts.camelCase(text);
            }
            return text;
        }
        
        /// <summary>
        /// Emit HTML hidden input field for each specified Key/Value pair entry
        /// </summary>
        public static string HtmlHiddenInputs(IEnumerable<KeyValuePair<string,object>> inputValues)
        {
            if (inputValues != null)
            {
                var sb = StringBuilderCache.Allocate();
                foreach (var entry in inputValues)
                {
                    sb.AppendLine($"<input type=\"hidden\" name=\"{entry.Key.HtmlEncode()}\" value=\"{entry.Value?.ToString().HtmlEncode()}\">");
                }
                return StringBuilderCache.ReturnAndFree(sb);
            }
            return null;
        }

        internal static object GetItem(this IRequest httpReq, string key)
        {
            if (httpReq == null) return null;

            httpReq.Items.TryGetValue(key, out var value);
            return value;
        }
        
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ResponseStatus GetErrorStatus(IRequest req) => 
            req.GetItem("__errorStatus") as ResponseStatus; // Keywords.ErrorStatus

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool HasErrorStatus(IRequest req) => GetErrorStatus(req) != null; 
        
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static string FormQuery(IRequest req, string name) => req.FormData[name] ?? req.QueryString[name];
        public static string[] FormQueryValues(IRequest req, string name)
        {
            var values = req.Verb == HttpMethods.Post 
                ? req.FormData.GetValues(name) 
                : req.QueryString.GetValues(name);

            return values?.Length == 1 // if it's only a single item can be returned in comma-delimited list
                ? values[0].Split(',') 
                : values ?? TypeConstants.EmptyStringArray;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static string FormValue(IRequest req, string name) => FormValue(req, name, null);

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static string FormValue(IRequest req, string name, string defaultValue) => HasErrorStatus(req) 
            ? FormQuery(req, name) 
            : defaultValue;

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static string[] FormValues(IRequest req, string name) => HasErrorStatus(req) 
            ? FormQueryValues(req, name) 
            : null;

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool FormCheckValue(IRequest req, string name)
        {
            var value = FormValue(req, name);
            return value is "true" or "True" or "t" or "on" or "1";
        }

        public static string GetParam(IRequest req, string name) //sync with IRequest.GetParam()
        {
            string value;
            if ((value = req.Headers[HttpHeaders.XParamOverridePrefix + name]) != null) return value;
            if ((value = req.QueryString[name]) != null) return value;
            if ((value = req.FormData[name]) != null) return value;

            //IIS will assign null to params without a name: .../?some_value can be retrieved as req.Params[null]
            //TryGetValue is not happy with null dictionary keys, so we should bail out here
            if (string.IsNullOrEmpty(name)) return null;

            if (req.Cookies.TryGetValue(name, out var cookie)) return cookie.Value;

            if (req.Items.TryGetValue(name, out var oValue)) return oValue.ToString();

            return null;
        }

        /// <summary>
        /// Comma delimited field names
        /// </summary>
        public static List<string> ToVarNames(string fieldNames) =>
            fieldNames.Split(',').Map(x => x.Trim());

        public static IEnumerable<string> ToStrings(string filterName, object arg)
        {
            if (arg == null)
                return TypeConstants.EmptyStringArray;
            
            var strings = arg is IEnumerable<string> ls
                ? ls
                : arg is string s
                    ? new [] { s }
                    : arg is IEnumerable<object> e
                        ? e.Map(x => x.AsString())
                        : throw new NotSupportedException($"{filterName} expected a collection of strings but was '{arg.GetType().Name}'");

            return strings;
        }

        /// <summary>
        /// Show validation summary error message unless there's an error in exceptFor list of fields
        /// as validation errors will be displayed along side the field instead
        /// </summary>
        public static string ValidationSummary(ResponseStatus errorStatus, string exceptFor) =>
            ValidationSummary(errorStatus, ToVarNames(exceptFor), null); 
        public static string ValidationSummary(ResponseStatus errorStatus, ICollection<string> exceptFields, Dictionary<string,object> divAttrs)
        {
            var errorSummaryMsg = exceptFields != null
                ? ErrorResponseExcept(errorStatus, exceptFields)
                : ErrorResponseSummary(errorStatus);

            if (string.IsNullOrEmpty(errorSummaryMsg))
                return null;

            if (divAttrs == null)
                divAttrs = new Dictionary<string, object>();
            
            if (!divAttrs.ContainsKey("class") && !divAttrs.ContainsKey("className"))
                divAttrs["class"] = ValidationSummaryCssClassNames;
            
            return HtmlScripts.htmlDiv(errorSummaryMsg, divAttrs).ToRawString();
        }
        
        public static string ValidationSummaryCssClassNames = "alert alert-danger";
        public static string ValidationSuccessCssClassNames = "alert alert-success";

        /// <summary>
        /// Display a "Success Alert Box"
        /// </summary>
        public static string ValidationSuccess(string message, Dictionary<string,object> divAttrs)
        {
            if (divAttrs == null)
                divAttrs = new Dictionary<string, object>();
            
            if (!divAttrs.ContainsKey("class") && !divAttrs.ContainsKey("className"))
                divAttrs["class"] = ValidationSuccessCssClassNames;
            
            return HtmlScripts.htmlDiv(message, divAttrs).ToRawString();
        }
        
        /// <summary>
        /// Return an error message unless there's an error in fieldNames
        /// </summary>
        public static string ErrorResponseExcept(ResponseStatus errorStatus, string fieldNames) =>
            ErrorResponseExcept(errorStatus, ToVarNames(fieldNames));
        public static string ErrorResponseExcept(ResponseStatus errorStatus, ICollection<string> fieldNames)
        {
            if (errorStatus == null)
                return null;
            
            var fieldNamesLookup = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
            foreach (var fieldName in fieldNames)
            {
                fieldNamesLookup.Add(fieldName);
            }

            if (!fieldNames.IsEmpty() && !errorStatus.Errors.IsEmpty())
            {
                foreach (var fieldError in errorStatus.Errors)
                {
                    if (fieldNamesLookup.Contains(fieldError.FieldName))
                        return null;
                }

                var firstFieldError = errorStatus.Errors[0];
                return firstFieldError.Message ?? firstFieldError.ErrorCode;
            }

            return errorStatus.Message ?? errorStatus.ErrorCode;
        }
        
        /// <summary>
        /// Return an error message unless there are field errors
        /// </summary>
        public static string ErrorResponseSummary(ResponseStatus errorStatus)
        {
            if (errorStatus == null)
                return null;

            return errorStatus.Errors.IsEmpty()
                ? errorStatus.Message ?? errorStatus.ErrorCode
                : null;
        }
        
        /// <summary>
        /// Return an error for the specified field (if any)  
        /// </summary>
        public static string ErrorResponse(ResponseStatus errorStatus, string fieldName)
        {
            if (fieldName == null)
                return ErrorResponseSummary(errorStatus);
            if (errorStatus == null || errorStatus.Errors.IsEmpty())
                return null;

            foreach (var fieldError in errorStatus.Errors)
            {
                if (fieldName.EqualsIgnoreCase(fieldError.FieldName))
                    return fieldError.Message ?? fieldError.ErrorCode;
            }

            return null;
        }

        public static List<KeyValuePair<string, string>> ToKeyValues(object values)
        {
            var to = new List<KeyValuePair<string, string>>();
            if (values != null)
            {
                if (values is IEnumerable<KeyValuePair<string, object>> kvps)
                    foreach (var kvp in kvps) to.Add(new KeyValuePair<string,string>(kvp.Key, kvp.Value?.ToString()));
                else if (values is IEnumerable<KeyValuePair<string, string>> kvpsStr)
                    foreach (var kvp in kvpsStr) to.Add(new KeyValuePair<string,string>(kvp.Key, kvp.Value));
                else if (values is IEnumerable<object> list)
                    to.AddRange(from string item in list select item.AsString() into s select new KeyValuePair<string, string>(s, s));
            }
            return to;
        }
        
        public static List<string> SplitStringList(IEnumerable strings) => strings is null
            ? TypeConstants.EmptyStringList
            : strings is List<string> strList
                ? strList
                : strings is IEnumerable<string> strEnum
                    ? strEnum.ToList()
                    : strings is IEnumerable<object> objEnum
                        ? objEnum.Map(x => x.AsString())
                        : strings is string strFields
                            ? strFields.Split(',').Map(x => x.Trim())
                            : throw new NotSupportedException($"Cannot convert '{strings.GetType().Name}' to List<string>");
        
        public static List<string> ToStringList(IEnumerable strings) => strings is List<string> l ? l
            : strings is string s 
            ? new List<string> { s } 
            : strings is IEnumerable<string> e
            ? new List<string>(e)
            : strings.Map(x => x.AsString());

        public static string FormControl(IRequest req, Dictionary<string,object> args, string tagName, InputOptions inputOptions)
        {
            if (tagName == null)
                tagName = "input";
            
            var options = inputOptions ?? new InputOptions();

            string id = null;
            string type = null;
            string name = null;
            string label = null;
            string size = options.Size;
            bool inline = options.Inline;

            if (args.TryGetValue("type", out var oType))
                type = oType as string;
            else
                args["type"] = type = "text";

            var notInput = tagName != "input";
            if (notInput)
            {
                type = tagName;
                args.RemoveKey("type");
            }

            var inputClass = "form-control";
            var labelClass = "form-label";
            var helpClass = "text-muted";
            var isCheck = type == "checkbox" || type == "radio";
            if (isCheck)
            {
                inputClass = "form-check-input";
                labelClass = "form-check-label";
                if (!args.ContainsKey("value"))
                    args["value"] = "true";
            }
            else if (type == "range")
            {
                inputClass = "form-control-range";
            }
            if (options.LabelClass != null)
                labelClass = options.LabelClass;

            if (args.TryGetValue("id", out var oId))
            {
                if (!args.ContainsKey("name"))
                    args["name"] = id = oId as string;

                if (args.TryGetValue("name", out var oName))
                    name = oName as string;
            }

            string help = options.Help;
            string helpId = help != null ? (id ?? name) + "-help" : null;
            if (helpId != null)
                args["aria-describedby"] = helpId;

            if (options.Label != null)
            {
                label = options.Label;
                if (!args.ContainsKey("placeholder"))
                    args["placeholder"] = label;
            }

            var values = options.Values;
            var isSingleCheck = isCheck && values == null;

            object oValue = null;
            string formValue = null;
            var isGet = req.Verb == HttpMethods.Get;
            var preserveValue = options.PreserveValue;
            if (preserveValue)
            {
                var strValue = args.TryGetValue("value", out oValue) ? oValue as string : null;
                formValue = FormValue(req, name, strValue);
                if (!isGet || !string.IsNullOrEmpty(formValue)) //only override value if POST or GET queryString has value
                {
                    if (!isCheck)
                        args["value"] = formValue;
                    else if (isSingleCheck)
                        args["checked"] = formValue == "true";
                }
            }
            else if (!isGet)
            {
                if (!isCheck)
                {
                    args["value"] = null;
                }
            }

            var className = args.TryGetValue("class", out var oCls) || args.TryGetValue("className", out oCls)
                ? HtmlScripts.htmlClassList(oCls)
                : "";
            
            className = HtmlScripts.htmlAddClass(className, inputClass);

            if (size != null)