namespace Kit.Helpers.Routes
{
    using Microsoft.AspNetCore.Routing;
    using Microsoft.AspNetCore.Mvc;
    using Microsoft.Extensions.DependencyInjection;
    using Microsoft.AspNetCore.Http;

    public static class RouteHelper_Extensions
    {

        private static IInlineConstraintResolver CreateInlineConstraintResolver(IServiceProvider serviceProvider)
        {
            var inlineConstraintResolver = serviceProvider
                .GetRequiredService<IInlineConstraintResolver>();

            var parameterPolicyFactory = serviceProvider
                .GetRequiredService<ParameterPolicyFactory>();

            // This inline constraint resolver will return a null constraint for non-IRouteConstraint
            // parameter policies so Route does not error
            return new BackCompatInlineConstraintResolver(inlineConstraintResolver, parameterPolicyFactory);
        }

        internal class NullRouteConstraint : IRouteConstraint
        {
            public static readonly NullRouteConstraint Instance = new NullRouteConstraint();

            private NullRouteConstraint()
            {
            }

            public bool Match(HttpContext httpContext, IRouter route, string routeKey, RouteValueDictionary values, RouteDirection routeDirection)
            {
                return true;
            }
        }
        private class BackCompatInlineConstraintResolver : IInlineConstraintResolver
        {
            private readonly IInlineConstraintResolver _inner;
            private readonly ParameterPolicyFactory _parameterPolicyFactory;

            public BackCompatInlineConstraintResolver(IInlineConstraintResolver inner, ParameterPolicyFactory parameterPolicyFactory)
            {
                _inner = inner;
                _parameterPolicyFactory = parameterPolicyFactory;
            }

            public IRouteConstraint ResolveConstraint(string inlineConstraint)
            {
                var routeConstraint = _inner.ResolveConstraint(inlineConstraint);
                if (routeConstraint != null)
                {
                    return routeConstraint;
                }

                var parameterPolicy = _parameterPolicyFactory.Create(null, inlineConstraint);
                if (parameterPolicy != null)
                {
                    // Logic inside Route will skip adding NullRouteConstraint
                    return NullRouteConstraint.Instance;
                }

                return null;
            }
        }



        public static RouteFluent AddRoute(this IRouteBuilder routeBuilder, string name, string url)
        {
            var inline = CreateInlineConstraintResolver(routeBuilder.ServiceProvider);
            var route = new Route(routeBuilder.DefaultHandler, name, url, null, null, null, inline);
            routeBuilder.Routes.Add(route);
            return new RouteFluent { Route = route };
        }

        public static RouteFluent AddRoute(this IRouteBuilder routeBuilder, string name, string url, string controller, string action)
        {
            var inline = CreateInlineConstraintResolver(routeBuilder.ServiceProvider);
            var route = new Route(routeBuilder.DefaultHandler, name, url, new RouteValueDictionary(new { controller = controller, action = action }), null, null, inline);
            routeBuilder.Routes.Add(route);
            return new RouteFluent { Route = route };
        }

        public static ControllerRouteFluent<TController> AddController<TController>(this IRouteBuilder routeTable)
            where TController : ControllerBase
        {
            return new ControllerRouteFluent<TController>(routeTable);
        }

        public static RouteBase GetBaseRoute(this ControllerContext context)
        {
            return context.GetBaseRoute();
            //ParentActionViewContext != null
            //       ? context.ParentActionViewContext.GetBaseRoute()
            //       : context.GetBaseRoute();
        }
    }
}

//public class PermissionGroup
//{
//    public RouteEx Route { get; set; }
//    public string Group { get; set; }
//}



//public static class RouteHelpers
//{
//    public static RouteEx IsHttpGet(this RouteEx route)
//    {
//        route.Route.DataTokens.Add("APP_IsHttpGet", true);
//        return route;
//    }

//    public static RouteEx IsHttpPost(this RouteEx route)
//    {
//        route.Route.DataTokens.Add("APP_IsHttpPost", true);
//        return route;
//    }

//    public static RouteEx AddRoute(this RouteCollection routes, string url)
//    {
//        return new RouteEx
//        {
//            Route = routes.MapRoute(null, url)
//        };
//    }

//    public static RouteEx AddRoute(this RouteCollection routes, string url, object defaults)
//    {
//        return new RouteEx
//        {
//            Route = routes.MapRoute(null, url, defaults)
//        };
//    }


//    public static PermissionGroup AddGroupPermission(this RouteEx route, string key, string permission)
//    {
//        var group = new PermissionGroup
//        {
//            Route = route,
//            Group = $"{Guid.NewGuid()}"
//                   .Replace("-", string.Empty)
//                   .Replace("{", string.Empty)
//                   .Replace("}", string.Empty)
//                   .ToLower()
//        };

//        Dictionary<string, List<KeyValuePair<string, string>>> permissions = null;

//        if (route.Route.DataTokens.ContainsKey("APP_RoutePermission"))
//        {
//            permissions = route.Route.DataTokens["APP_RoutePermission"] as Dictionary<string, List<KeyValuePair<string, string>>>;
//        }
//        else
//        {
//            permissions = new Dictionary<string, List<KeyValuePair<string, string>>>();
//            route.Route.DataTokens.Add("APP_RoutePermission", permissions);
//        }
//        var item = new List<KeyValuePair<string, string>>();
//        item.Add(new KeyValuePair<string, string>(key, permission));
//        permissions.Add(group.Group, item);

//        route.Route.DataTokens["APP_RoutePermission"] = permissions;

//        return group;
//    }

//    public static PermissionGroup AddPermission(this PermissionGroup route, string key, string permission)
//    {
//        var permissions = route.Route.Route.DataTokens["APP_RoutePermission"] as Dictionary<string, List<KeyValuePair<string, string>>>;
//        permissions[route.Group].Add(new KeyValuePair<string, string>(key, permission));
//        route.Route.Route.DataTokens["APP_RoutePermission"] = permissions;
//        return route;
//    }
//}