using Dpz.Core.Public.Entity.Seo;

namespace Dpz.Core.Service.RepositoryServiceImpl;

public class PageMetadataService(
    IRepository<PageMetadata> repository,
    IMapper mapper,
    IPageRouteCatalogService pageRouteCatalogService
) : IPageMetadataService
{
    private static List<string> NormalizeRelations(IEnumerable<string>? relations)
    {
        return relations
                ?.Where(x => !string.IsNullOrWhiteSpace(x))
                .Select(x => x.Trim().ToLowerInvariant())
                .Distinct()
                .OrderBy(x => x)
                .ToList()
            ?? [];
    }

    private static string BuildRelationPath(IEnumerable<string>? relations)
    {
        return string.Join("/", NormalizeRelations(relations));
    }

    private static bool IsLegacyRelationMatch(
        IReadOnlyCollection<string> left,
        IReadOnlyCollection<string> right
    )
    {
        var leftPath = BuildRelationPath(left);
        var rightPath = BuildRelationPath(right);
        return string.Equals(leftPath, rightPath, StringComparison.Ordinal);
    }

    private async Task<IList<PageMetadata>> GetAllEntitiesAsync(
        CancellationToken cancellationToken = default
    )
    {
        return await repository.SearchFor(x => true).ToListAsync(cancellationToken);
    }

    private async Task<PageMetadata?> FindLegacyAsync(
        IReadOnlyCollection<string> relations,
        CancellationToken cancellationToken = default
    )
    {
        var normalizedRelations = NormalizeRelations(relations);
        if (normalizedRelations.Count == 0)
        {
            return null;
        }

        var exactMatch = await repository
            .SearchFor(x => x.Relations == normalizedRelations)
            .FirstOrDefaultAsync(cancellationToken);
        if (exactMatch != null)
        {
            return exactMatch;
        }

        var list = await GetAllEntitiesAsync(cancellationToken);
        return list.FirstOrDefault(x => IsLegacyRelationMatch(x.Relations, relations));
    }

    public async Task<VmPageMetadata?> GetPageMetadataAsync(
        IReadOnlyCollection<string> relations,
        CancellationToken cancellationToken = default
    )
    {
        var entity = await FindLegacyAsync(relations, cancellationToken);
        return entity == null ? null : mapper.Map<VmPageMetadata>(entity);
    }

    public Task<VmPageMetadata?> GetPageMetadataByRouteAsync(
        string? controller,
        string? action,
        string? routeId = null,
        CancellationToken cancellationToken = default
    )
    {
        var route = new PageMetadataRoute
        {
            Controller = controller,
            Action = action,
            Parameters = string.IsNullOrWhiteSpace(routeId)
                ? []
                : new Dictionary<string, string> { ["id"] = routeId },
        };
        return GetPageMetadataByRouteAsync(route, cancellationToken);
    }

    public async Task<VmPageMetadata?> GetPageMetadataByRouteAsync(
        PageMetadataRoute route,
        CancellationToken cancellationToken = default
    )
    {
        var normalizedRoute = route.Normalize();
        if (
            string.IsNullOrWhiteSpace(normalizedRoute.Controller)
            || string.IsNullOrWhiteSpace(normalizedRoute.Action)
        )
        {
            return null;
        }

        var list = await GetPageMetadataAsync(cancellationToken);
        return FindRouteMetadata(list, normalizedRoute)
            ?? FindLegacyRouteMetadata(list, normalizedRoute);
    }

    public async Task<VmPageMetadata?> ResolvePageMetadataAsync(
        PageMetadataRoute route,
        VmPageMetadata? explicitMetadata = null,
        CancellationToken cancellationToken = default
    )
    {
        var publicMetadata = await GetPublicMetadataAsync(cancellationToken);
        var routeMetadata = await GetPageMetadataByRouteAsync(route, cancellationToken);

        var shouldInheritPublic = ShouldInheritPublic(
            publicMetadata,
            routeMetadata,
            explicitMetadata
        );
        var mergedSources = new List<VmPageMetadata>();
        if (shouldInheritPublic && publicMetadata != null)
        {
            mergedSources.Add(publicMetadata);
        }

        if (routeMetadata != null)
        {
            mergedSources.Add(routeMetadata);
        }

        if (explicitMetadata != null)
        {
            mergedSources.Add(explicitMetadata);
        }

        return Merge(mergedSources);
    }

    [Cache(ExpirationSeconds = ExpirationTime.Day)]
    public async Task<VmPageMetadata?> GetPublicMetadataAsync(
        CancellationToken cancellationToken = default
    )
    {
        var entity = await repository
            .SearchFor(x => x.IsPublicMetadata)
            .FirstOrDefaultAsync(cancellationToken);
        return entity == null ? null : mapper.Map<VmPageMetadata>(entity);
    }

    [Cache(ExpirationSeconds = ExpirationTime.Day)]
    public async Task<VmPageMetadata?> GetByIdAsync(
        string id,
        CancellationToken cancellationToken = default
    )
    {
        var entity = await repository.TryGetAsync(id, cancellationToken);
        return entity == null ? null : mapper.Map<VmPageMetadata>(entity);
    }

    [Cache(ExpirationSeconds = ExpirationTime.Day)]
    public async Task<IPagedList<VmPageMetadata>> GetPageAsync(
        string? searchText = null,
        int pageIndex = 1,
        int pageSize = 20,
        CancellationToken cancellationToken = default
    )
    {
        var filter = Builders<PageMetadata>.Filter.Empty;
        if (!string.IsNullOrWhiteSpace(searchText))
        {
            var regex = new BsonRegularExpression(searchText, "i");
            filter = Builders<PageMetadata>.Filter.Or(
                Builders<PageMetadata>.Filter.Regex(x => x.RouteKey, regex),
                Builders<PageMetadata>.Filter.Regex(x => x.Relations, regex),
                Builders<PageMetadata>.Filter.Regex(x => x.Title, regex),
                Builders<PageMetadata>.Filter.Regex(x => x.Description, regex)
            );
        }

        return await repository
            .SearchFor(filter)
            .ToPagedListAsync<PageMetadata, VmPageMetadata>(pageIndex, pageSize, cancellationToken);
    }

    [Cache(ExpirationSeconds = ExpirationTime.Day)]
    public async Task<IList<VmPageMetadata>> GetPageMetadataAsync(
        CancellationToken cancellationToken = default
    )
    {
        var list = await GetAllEntitiesAsync(cancellationToken);
        return mapper.Map<List<VmPageMetadata>>(list);
    }

    [InvalidateCache(
        Methods = [
            nameof(GetByIdAsync),
            nameof(GetPageAsync),
            nameof(GetPageMetadataAsync),
            nameof(GetPublicMetadataAsync),
        ]
    )]
    public async Task SavePageMetadataAsync(
        VmPageMetadata pageMetadata,
        CancellationToken cancellationToken = default
    )
    {
        if (
            pageMetadata.IsPublicMetadata
            && (pageMetadata.Route != null || pageMetadata.Relations.Count > 0)
        )
        {
            throw new ArgumentException("public metadata cannot contain route or relations");
        }

        NormalizePageMetadata(pageMetadata);
        await ValidatePageMetadataAsync(pageMetadata, cancellationToken);

        var entity = await FindSaveTargetAsync(pageMetadata, cancellationToken);
        if (!string.IsNullOrWhiteSpace(pageMetadata.Id) && entity == null)
        {
            return;
        }

        if (entity != null)
        {
            await UpdateAsync(entity, pageMetadata, cancellationToken);
            return;
        }

        var insertEntity = mapper.Map<PageMetadata>(pageMetadata);
        await repository.InsertAsync(insertEntity, cancellationToken);
    }

    [InvalidateCache(
        Methods = [
            nameof(GetByIdAsync),
            nameof(GetPageAsync),
            nameof(GetPageMetadataAsync),
            nameof(GetPublicMetadataAsync),
        ]
    )]
    public Task RefreshCacheAsync(CancellationToken cancellationToken = default)
    {
        return Task.CompletedTask;
    }

    [InvalidateCache(
        Methods = [
            nameof(GetByIdAsync),
            nameof(GetPageAsync),
            nameof(GetPageMetadataAsync),
            nameof(GetPublicMetadataAsync),
        ]
    )]
    public async Task DeleteAsync(string id, CancellationToken cancellationToken = default)
    {
        await repository.DeleteAsync(id, cancellationToken);
    }

    private async Task<PageMetadata?> FindSaveTargetAsync(
        VmPageMetadata pageMetadata,
        CancellationToken cancellationToken
    )
    {
        if (!string.IsNullOrWhiteSpace(pageMetadata.Id))
        {
            return await repository.TryGetAsync(pageMetadata.Id, cancellationToken);
        }

        if (pageMetadata.IsPublicMetadata)
        {
            return await repository
                .SearchFor(x => x.IsPublicMetadata)
                .FirstOrDefaultAsync(cancellationToken);
        }

        return await repository
            .SearchFor(x => x.RouteKey == pageMetadata.RouteKey && !x.IsPublicMetadata)
            .FirstOrDefaultAsync(cancellationToken);
    }

    private async Task ValidatePageMetadataAsync(
        VmPageMetadata pageMetadata,
        CancellationToken cancellationToken
    )
    {
        if (pageMetadata.IsPublicMetadata)
        {
            if (pageMetadata.Route != null || pageMetadata.Relations.Count > 0)
            {
                throw new ArgumentException("public metadata cannot contain route or relations");
            }

            if (!string.IsNullOrWhiteSpace(pageMetadata.Id))
            {
                var publicEntity = await repository
                    .SearchFor(x => x.IsPublicMetadata)
                    .FirstOrDefaultAsync(cancellationToken);
                if (
                    publicEntity != null
                    && !string.Equals(
                        publicEntity.Id.ToString(),
                        pageMetadata.Id,
                        StringComparison.Ordinal
                    )
                )
                {
                    throw new ArgumentException("public metadata already exists");
                }
            }

            return;
        }

        if (pageMetadata.Route == null)
        {
            throw new ArgumentException("route is required for page metadata");
        }

        var validation = await pageRouteCatalogService.ValidateRouteAsync(
            pageMetadata.Route,
            cancellationToken
        );
        if (!validation.IsValid)
        {
            throw new ArgumentException(validation.ErrorMessage ?? "route is invalid");
        }
    }

    private async Task UpdateAsync(
        PageMetadata entity,
        VmPageMetadata pageMetadata,
        CancellationToken cancellationToken
    )
    {
        var update = Builders<PageMetadata>
            .Update.Set(x => x.IsPublicMetadata, pageMetadata.IsPublicMetadata)
            .Set(x => x.ApplyToUnconfiguredPages, pageMetadata.ApplyToUnconfiguredPages)
            .Set(x => x.InheritanceMode, pageMetadata.InheritanceMode)
            .Set(x => x.Route, pageMetadata.Route)
            .Set(x => x.RouteKey, pageMetadata.RouteKey)
            .Set(x => x.Title, pageMetadata.Title)
            .Set(x => x.Keywords, pageMetadata.Keywords)
            .Set(x => x.Description, pageMetadata.Description)
            .Set(x => x.Metas, pageMetadata.Metas)
            .Set(x => x.Relations, pageMetadata.Relations);
        await repository.UpdateAsync(x => x.Id == entity.Id, update, cancellationToken);
    }

    private static void NormalizePageMetadata(VmPageMetadata pageMetadata)
    {
        pageMetadata.Keywords = pageMetadata
            .Keywords.Where(x => !string.IsNullOrWhiteSpace(x))
            .Select(x => x.Trim())
            .Distinct(StringComparer.OrdinalIgnoreCase)
            .ToList();
        pageMetadata.Metas = pageMetadata
            .Metas.Where(x => !string.IsNullOrWhiteSpace(x.Key))
            .ToDictionary(x => x.Key.Trim(), x => x.Value?.Trim() ?? "", StringComparer.Ordinal);

        if (pageMetadata.IsPublicMetadata)
        {
            pageMetadata.InheritanceMode = PageMetadataInheritanceMode.Inherit;
            pageMetadata.Route = null;
            pageMetadata.RouteKey = null;
            pageMetadata.Relations = [];
            return;
        }

        pageMetadata.ApplyToUnconfiguredPages = false;
        pageMetadata.Relations = [];
        pageMetadata.Route = pageMetadata.Route?.Normalize();
        pageMetadata.RouteKey = pageMetadata.Route?.BuildRouteKey();
    }

    private static VmPageMetadata? FindRouteMetadata(
        IList<VmPageMetadata> metadataList,
        PageMetadataRoute route
    )
    {
        var requestActionKey = route.BuildActionKey();
        var requestRouteKey = route.BuildRouteKey();
        var requestParameters = route.Parameters;
        return metadataList
            .Where(x => !x.IsPublicMetadata && x.Route != null)
            .Select(x => new { Metadata = x, Route = x.Route!.Normalize() })
            .Where(x =>
                string.Equals(x.Route.BuildActionKey(), requestActionKey, StringComparison.Ordinal)
            )
            .Where(x => IsParameterSubset(x.Route.Parameters, requestParameters))
            .OrderByDescending(x => x.Route.Parameters.Count)
            .ThenByDescending(x =>
                string.Equals(x.Metadata.RouteKey, requestRouteKey, StringComparison.Ordinal)
            )
            .Select(x => x.Metadata)
            .FirstOrDefault();
    }

    private static VmPageMetadata? FindLegacyRouteMetadata(
        IList<VmPageMetadata> metadataList,
        PageMetadataRoute route
    )
    {
        var relations = new List<string>();
        if (!string.IsNullOrWhiteSpace(route.Controller))
        {
            relations.Add(route.Controller);
        }

        if (!string.IsNullOrWhiteSpace(route.Action))
        {
            relations.Add(route.Action);
        }

        if (route.Parameters.TryGetValue("id", out var id) && !string.IsNullOrWhiteSpace(id))
        {
            relations.Add(id);
        }

        if (relations.Count < 2)
        {
            return null;
        }

        return metadataList
            .Where(x => !x.IsPublicMetadata && x.Route == null && x.Relations.Count > 0)
            .OrderByDescending(x => x.Relations.Count)
            .FirstOrDefault(x => IsLegacyRelationMatch(x.Relations, relations));
    }

    private static bool IsParameterSubset(
        IReadOnlyDictionary<string, string> candidate,
        IReadOnlyDictionary<string, string> request
    )
    {
        foreach (var (key, value) in candidate)
        {
            if (!request.TryGetValue(key, out var requestValue))
            {
                return false;
            }

            if (!string.Equals(value, requestValue, StringComparison.Ordinal))
            {
                return false;
            }
        }

        return true;
    }

    private static bool ShouldInheritPublic(
        VmPageMetadata? publicMetadata,
        VmPageMetadata? routeMetadata,
        VmPageMetadata? explicitMetadata
    )
    {
        if (publicMetadata == null)
        {
            return false;
        }

        if (explicitMetadata?.InheritanceMode == PageMetadataInheritanceMode.Ignore)
        {
            return false;
        }

        if (routeMetadata != null)
        {
            return routeMetadata.InheritanceMode == PageMetadataInheritanceMode.Inherit;
        }

        return explicitMetadata != null || publicMetadata.ApplyToUnconfiguredPages;
    }

    private static VmPageMetadata? Merge(IReadOnlyCollection<VmPageMetadata> sources)
    {
        if (sources.Count == 0)
        {
            return null;
        }

        var result = new VmPageMetadata();
        var metas = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
        var keywords = new List<string>();
        foreach (var source in sources)
        {
            foreach (var (key, value) in source.Metas)
            {
                metas[key] = value;
            }

            foreach (var keyword in source.Keywords)
            {
                if (keywords.Contains(keyword, StringComparer.OrdinalIgnoreCase))
                {
                    continue;
                }

                keywords.Add(keyword);
            }

            if (!string.IsNullOrWhiteSpace(source.Title))
            {
                result.Title = source.Title;
            }

            if (!string.IsNullOrWhiteSpace(source.Description))
            {
                result.Description = source.Description;
            }

            result.Route ??= source.Route;
            result.RouteKey ??= source.RouteKey;
            result.Relations = source.Relations.Count > 0 ? source.Relations : result.Relations;
        }

        result.Metas = metas.ToDictionary(x => x.Key, x => x.Value, StringComparer.Ordinal);
        result.Keywords = keywords;
        result.InheritanceMode = PageMetadataInheritanceMode.Inherit;
        return result;
    }
}