using Dpz.Core.Public.Entity.Auth;
using Dpz.Core.Service.Mediator.Features.Auth.Contracts;

namespace Dpz.Core.Service.Mediator.Features.Auth.Queries;

public class SearchUserAuthorizationsQueryHandler(
    IRepository<DpzAuthorization> authorizationRepository,
    IRepository<DpzApplication> applicationRepository
) : IRequestHandler<SearchUserAuthorizationsQuery, PagedListWarp<AuthAuthorizationPageItem>>
{
    public async ValueTask<PagedListWarp<AuthAuthorizationPageItem>> Handle(
        SearchUserAuthorizationsQuery request,
        CancellationToken cancellationToken
    )
    {
        if (string.IsNullOrWhiteSpace(request.Account))
        {
            return new PagedListWarp<AuthAuthorizationPageItem>(request.Page, request.Limit, 0, []);
        }

        var query = authorizationRepository.SearchFor(x => x.Subject == request.Account);

        if (
            !string.IsNullOrWhiteSpace(request.ApplicationId)
            && ObjectId.TryParse(request.ApplicationId, out var appId)
        )
        {
            query = query.Where(x => x.ApplicationId == appId);
        }

        if (!string.IsNullOrWhiteSpace(request.Status))
        {
            query = query.Where(x => x.Status == request.Status);
        }

        if (!string.IsNullOrWhiteSpace(request.Type))
        {
            query = query.Where(x => x.Type == request.Type);
        }

        if (!string.IsNullOrWhiteSpace(request.Keyword))
        {
            var keyword = request.Keyword.Trim();
            query = query.Where(x =>
                (x.Status != null && x.Status.Contains(keyword))
                || (x.Type != null && x.Type.Contains(keyword))
                || (x.Scopes != null && x.Scopes.Any(scope => scope.Contains(keyword)))
            );
        }

        var pagedList = await query
            .OrderByDescending(x => x.CreationDate)
            .ToPagedListAsync(request.Page, request.Limit, cancellationToken);

        var applicationIds = pagedList.Select(x => x.ApplicationId).ToHashSet();
        var applications = await applicationRepository
            .SearchFor(Builders<DpzApplication>.Filter.In(x => x.Id, applicationIds))
            .ToListAsync(cancellationToken);

        var items = pagedList
            .Select(x =>
            {
                var app = applications.FirstOrDefault(y => y.Id == x.ApplicationId);
                return new AuthAuthorizationPageItem
                {
                    Id = x.Id.ToString(),
                    ApplicationId = x.ApplicationId.ToString(),
                    ApplicationName = app?.DisplayName ?? string.Empty,
                    Status = x.Status,
                    Type = x.Type,
                    CreationDate = x.CreationDate,
                    Scopes = x.Scopes?.ToList() ?? [],
                };
            })
            .ToList();

        return new PagedListWarp<AuthAuthorizationPageItem>(
            pagedList.CurrentPageIndex,
            pagedList.PageSize,
            pagedList.TotalItemCount,
            items
        );
    }
}