using Dpz.Core.Public.Entity.Seo;

namespace Dpz.Core.Service.RepositoryServiceImpl;

public class PageRouteCatalogService(IRepository<PageRouteDefinition> repository, IMapper mapper)
    : IPageRouteCatalogService
{
    [Cache(ExpirationSeconds = ExpirationTime.Week)]
    public async Task<IList<VmPageRouteDefinition>> GetRoutesAsync(
        bool activeOnly = true,
        CancellationToken cancellationToken = default
    )
    {
        var query = repository.SearchFor(x => true);
        if (activeOnly)
        {
            query = query.Where(x => x.IsActive);
        }

        var list = await query
            .OrderBy(x => x.Controller)
            .ThenBy(x => x.Action)
            .ToListAsync(cancellationToken);
        return mapper.Map<List<VmPageRouteDefinition>>(list);
    }

    public async Task<PageRouteValidationResult> ValidateRouteAsync(
        PageMetadataRoute route,
        CancellationToken cancellationToken = default
    )
    {
        var normalizedRoute = route.Normalize();
        if (string.IsNullOrWhiteSpace(normalizedRoute.Controller))
        {
            return PageRouteValidationResult.Fail("route.controller is required");
        }

        if (string.IsNullOrWhiteSpace(normalizedRoute.Action))
        {
            return PageRouteValidationResult.Fail("route.action is required");
        }

        var emptyParameters = normalizedRoute
            .Parameters.Where(x => string.IsNullOrWhiteSpace(x.Value))
            .Select(x => x.Key)
            .ToList();
        if (emptyParameters.Count > 0)
        {
            return PageRouteValidationResult.Fail(
                $"route parameters cannot be empty: {string.Join(",", emptyParameters)}"
            );
        }

        var routeKey = normalizedRoute.BuildActionKey();
        var routeDefinition = await repository
            .SearchFor(x => x.RouteKey == routeKey && x.IsActive)
            .FirstOrDefaultAsync(cancellationToken);
        if (routeDefinition == null)
        {
            return PageRouteValidationResult.Fail("route is not found in page route catalog");
        }

        var allowedParameters = routeDefinition
            .Parameters.Where(x => x.Source != PageRouteParameterSource.None)
            .Select(x => x.Name)
            .Where(x => !string.IsNullOrWhiteSpace(x))
            .Select(x => x.ToLowerInvariant())
            .ToHashSet(StringComparer.Ordinal);
        var invalidParameters = normalizedRoute
            .Parameters.Keys.Where(x => !allowedParameters.Contains(x))
            .ToList();
        if (invalidParameters.Count > 0)
        {
            return PageRouteValidationResult.Fail(
                $"route parameters are invalid: {string.Join(",", invalidParameters)}"
            );
        }

        return PageRouteValidationResult.Success;
    }

    [InvalidateCache(Methods = [nameof(GetRoutesAsync)])]
    public async Task SaveScannedRoutesAsync(
        IReadOnlyCollection<VmSavePageRouteDefinition> routes,
        CancellationToken cancellationToken = default
    )
    {
        var scanTime = DateTime.Now;
        var normalizedRoutes = routes
            .Select(NormalizeRoute)
            .Where(x =>
                !string.IsNullOrWhiteSpace(x.Controller) && !string.IsNullOrWhiteSpace(x.Action)
            )
            .GroupBy(x => PageMetadataRoute.BuildActionKey(x.Area, x.Controller, x.Action))
            .Select(x => MergeRouteDefinitions(x.Key, x, scanTime))
            .ToList();
        var scannedKeys = normalizedRoutes
            .Select(x => x.RouteKey)
            .ToHashSet(StringComparer.Ordinal);

        foreach (var route in normalizedRoutes)
        {
            var exists = await repository
                .SearchFor(x => x.RouteKey == route.RouteKey)
                .FirstOrDefaultAsync(cancellationToken);
            if (exists == null)
            {
                await repository.InsertAsync(route, cancellationToken);
                continue;
            }

            var update = Builders<PageRouteDefinition>
                .Update.Set(x => x.Area, route.Area)
                .Set(x => x.Controller, route.Controller)
                .Set(x => x.Action, route.Action)
                .Set(x => x.HttpMethods, route.HttpMethods)
                .Set(x => x.Endpoints, route.Endpoints)
                .Set(x => x.Parameters, route.Parameters)
                .Set(x => x.IsActive, true)
                .Set(x => x.LastScannedAt, scanTime);
            await repository.UpdateAsync(x => x.Id == exists.Id, update, cancellationToken);
        }

        var activeRoutes = await repository
            .SearchFor(x => x.IsActive)
            .ToListAsync(cancellationToken);
        var staleRoutes = activeRoutes.Where(x => !scannedKeys.Contains(x.RouteKey)).ToList();
        foreach (var staleRoute in staleRoutes)
        {
            var update = Builders<PageRouteDefinition>
                .Update.Set(x => x.IsActive, false)
                .Set(x => x.LastScannedAt, scanTime);
            await repository.UpdateAsync(x => x.Id == staleRoute.Id, update, cancellationToken);
        }
    }

    [InvalidateCache(Methods = [nameof(GetRoutesAsync)])]
    public Task RefreshCacheAsync(CancellationToken cancellationToken = default)
    {
        return Task.CompletedTask;
    }

    private static VmSavePageRouteDefinition NormalizeRoute(VmSavePageRouteDefinition route)
    {
        return new VmSavePageRouteDefinition
        {
            Area = PageMetadataRoute.NormalizeSegment(route.Area),
            Controller = PageMetadataRoute.NormalizeSegment(route.Controller) ?? string.Empty,
            Action = PageMetadataRoute.NormalizeSegment(route.Action) ?? string.Empty,
            HttpMethods = route
                .HttpMethods.Select(x => x.Trim().ToUpperInvariant())
                .Where(x => !string.IsNullOrWhiteSpace(x))
                .Distinct(StringComparer.Ordinal)
                .OrderBy(x => x, StringComparer.Ordinal)
                .ToList(),
            Endpoints = route
                .Endpoints.Select(NormalizeEndpoint)
                .Where(x => !string.IsNullOrWhiteSpace(x.Template))
                .GroupBy(BuildEndpointKey, StringComparer.Ordinal)
                .Select(x => x.First())
                .OrderBy(x => x.Template, StringComparer.OrdinalIgnoreCase)
                .ToList(),
            Parameters = route
                .Parameters.Select(NormalizeParameter)
                .Where(x => !string.IsNullOrWhiteSpace(x.Name))
                .GroupBy(x => x.Name, StringComparer.Ordinal)
                .Select(MergeParameters)
                .OrderBy(x => x.Name, StringComparer.Ordinal)
                .ToList(),
        };
    }

    private static VmPageRouteParameterDefinition NormalizeParameter(
        VmPageRouteParameterDefinition parameter
    )
    {
        return new VmPageRouteParameterDefinition
        {
            Name = PageMetadataRoute.NormalizeSegment(parameter.Name) ?? string.Empty,
            TypeName = parameter.TypeName,
            Source = parameter.Source,
            IsOptional = parameter.IsOptional,
        };
    }

    private static VmPageRouteEndpointDefinition NormalizeEndpoint(
        VmPageRouteEndpointDefinition endpoint
    )
    {
        return new VmPageRouteEndpointDefinition
        {
            RouteName = string.IsNullOrWhiteSpace(endpoint.RouteName)
                ? null
                : endpoint.RouteName.Trim(),
            Template = endpoint.Template.Trim(),
            HttpMethods = endpoint
                .HttpMethods.Select(x => x.Trim().ToUpperInvariant())
                .Where(x => !string.IsNullOrWhiteSpace(x))
                .Distinct(StringComparer.Ordinal)
                .OrderBy(x => x, StringComparer.Ordinal)
                .ToList(),
            Defaults = NormalizeValues(endpoint.Defaults),
            RequiredValues = NormalizeValues(endpoint.RequiredValues),
        };
    }

    private static Dictionary<string, string> NormalizeValues(
        IReadOnlyDictionary<string, string> values
    )
    {
        return values
            .Where(x => !string.IsNullOrWhiteSpace(x.Key))
            .Select(x => new KeyValuePair<string, string>(
                PageMetadataRoute.NormalizeSegment(x.Key) ?? string.Empty,
                x.Value?.Trim() ?? string.Empty
            ))
            .GroupBy(x => x.Key, StringComparer.Ordinal)
            .Select(x => x.Last())
            .OrderBy(x => x.Key, StringComparer.Ordinal)
            .ToDictionary(x => x.Key, x => x.Value, StringComparer.Ordinal);
    }

    private static string BuildEndpointKey(VmPageRouteEndpointDefinition endpoint)
    {
        return string.Join(
            "|",
            endpoint.RouteName ?? string.Empty,
            endpoint.Template.ToLowerInvariant(),
            string.Join(",", endpoint.HttpMethods),
            string.Join(",", endpoint.Defaults.Select(x => $"{x.Key}={x.Value}")),
            string.Join(",", endpoint.RequiredValues.Select(x => $"{x.Key}={x.Value}"))
        );
    }

    private static VmPageRouteParameterDefinition MergeParameters(
        IGrouping<string, VmPageRouteParameterDefinition> parameters
    )
    {
        return new VmPageRouteParameterDefinition
        {
            Name = parameters.Key,
            TypeName = parameters
                .Select(x => x.TypeName)
                .FirstOrDefault(x => !string.IsNullOrWhiteSpace(x)),
            Source = parameters.Aggregate(
                PageRouteParameterSource.None,
                (source, parameter) => source | parameter.Source
            ),
            IsOptional = parameters.All(x => x.IsOptional),
        };
    }

    private static PageRouteDefinition MergeRouteDefinitions(
        string routeKey,
        IEnumerable<VmSavePageRouteDefinition> routes,
        DateTime scanTime
    )
    {
        var routeList = routes.ToList();
        var first = routeList[0];
        return new PageRouteDefinition
        {
            RouteKey = routeKey,
            Area = first.Area,
            Controller = first.Controller,
            Action = first.Action,
            HttpMethods = routeList
                .SelectMany(x => x.HttpMethods)
                .Distinct(StringComparer.Ordinal)
                .OrderBy(x => x, StringComparer.Ordinal)
                .ToList(),
            Endpoints = routeList
                .SelectMany(x => x.Endpoints)
                .GroupBy(BuildEndpointKey, StringComparer.Ordinal)
                .Select(x => new PageRouteEndpointDefinition
                {
                    RouteName = x.First().RouteName,
                    Template = x.First().Template,
                    HttpMethods = x.First().HttpMethods,
                    Defaults = x.First().Defaults,
                    RequiredValues = x.First().RequiredValues,
                })
                .OrderBy(x => x.Template, StringComparer.OrdinalIgnoreCase)
                .ToList(),
            Parameters = routeList
                .SelectMany(x => x.Parameters)
                .GroupBy(x => x.Name, StringComparer.Ordinal)
                .Select(x => new PageRouteParameterDefinition
                {
                    Name = x.Key,
                    TypeName = x.Select(p => p.TypeName)
                        .FirstOrDefault(p => !string.IsNullOrWhiteSpace(p)),
                    Source = x.Aggregate(
                        PageRouteParameterSource.None,
                        (source, parameter) => source | parameter.Source
                    ),
                    IsOptional = x.All(p => p.IsOptional),
                })
                .OrderBy(x => x.Name, StringComparer.Ordinal)
                .ToList(),
            IsActive = true,
            LastScannedAt = scanTime,
        };
    }
}