using System.Threading;
using Dpz.Core.Public.ViewModel.Request;
using Dpz.Core.Public.ViewModel.RequestEvent;
using Dpz.Core.Public.ViewModel.Response;

namespace Dpz.Core.Service.RepositoryServiceImpl;

public class PictureRecordService(
    IRepository<PictureRecord> repository,
    IMapper mapper,
    IFusionCache fusionCache,
    IMediator mediator
) : AbstractCacheService(fusionCache), IPictureRecordService
{
    protected override TimeSpan CacheDefaultExpiration => TimeSpan.FromDays(1);

    private readonly IFusionCache _fusionCache = fusionCache;

    public async Task<List<string>> GetTagsAsync()
    {
        return await GetOrSetCacheAsync<List<string>>(
            nameof(GetTagsAsync),
            async (_, cancellationToken) =>
            {
                var tags = await repository
                    .MongodbQueryable
                    //.Select(x => x.Tags)
                    .SelectMany(x => x.Tags)
                    .GroupBy(x => x)
                    .Select(x => x.Key)
                    .ToListAsync(cancellationToken);
                return tags;
            }
        );
    }

    public async Task<ICollection<PictureRecordResponse>> GetBannerAsync()
    {
        return await GetOrSetCacheAsync<List<PictureRecordResponse>>(
            nameof(GetBannerAsync),
            async (_, _) =>
            {
                var pagedList = await repository
                    .SearchFor(x => x.Tags.Any(y => y == "banner"))
                    .OrderByDescending(x => x.UploadTime)
                    .ToListAsync<PictureRecord, PictureRecordResponse>();
                pagedList.ForEach(x => x.AccessUrl += "!banner");
                return pagedList;
            }
        );
    }

    public async Task<IPagedList<PictureRecordResponse>> GetPagesAsync(
        List<string>? tags,
        string? description,
        int pageIndex = 1,
        int pageSize = 20,
        string? account = null
    )
    {
        return await GetOrSetPagedListAsync<PictureRecordResponse>(
            nameof(GetPagesAsync),
            async _ =>
            {
                var filterEmpty = Builders<PictureRecord>.Filter.Empty;
                var filters = new List<FilterDefinition<PictureRecord>>();

                var clearTags =
                    tags?.Where(x => !string.IsNullOrEmpty(x)).Select(x => x).ToList() ?? [];
                if (clearTags.Count > 0)
                {
                    var filter = Builders<PictureRecord>.Filter.AnyIn(x => x.Tags, clearTags);
                    filters.Add(filter);
                }

                if (!string.IsNullOrEmpty(description))
                {
                    var filter = Builders<PictureRecord>.Filter.Regex(
                        x => x.Description,
                        new BsonRegularExpression(description, "i")
                    );
                    filters.Add(filter);
                }

                if (!string.IsNullOrEmpty(account))
                {
                    var filter = Builders<PictureRecord>.Filter.Eq(x => x.Creator.Id, account);
                    filters.Add(filter);
                }

                var filterResult =
                    filters.Count > 0 ? Builders<PictureRecord>.Filter.And(filters) : filterEmpty;

                return await repository
                    .SearchFor(filterResult)
                    .SortByDescending(x => x.Id)
                    .ToPagedListAsync<PictureRecord, PictureRecordResponse>(pageIndex, pageSize);
            },
            new
            {
                tags,
                description,
                pageIndex,
                pageSize,
                account,
            }
        );
    }

    public async Task<PictureRecordResponse?> GetPictureRecordAsync(string id)
    {
        return await GetOrSetCacheAsync<PictureRecordResponse?>(
            nameof(GetPictureRecordAsync),
            async (_, _) =>
            {
                var entity = await repository.TryGetAsync(id);
                return entity == null ? null : mapper.Map<PictureRecordResponse>(entity);
            },
            new { id }
        );
    }

    public async Task<PictureRecordResponse> CreateRecordAsync(
        CreatePictureRecordRequest request,
        CancellationToken cancellationToken = default
    )
    {
        var entity = mapper.Map<PictureRecord>(request);
        await repository.InsertAsync(entity, cancellationToken);
        if (entity.Tags.Any(x => x == "banner"))
        {
            await _fusionCache.RemoveAsync(CacheKey.HomeContainerKey, token: cancellationToken);
        }

        await ClearCacheAsync();
        return mapper.Map<PictureRecordResponse>(entity);
    }

    public async Task<PictureRecordResponse?> ChangeInformationAsync(
        EditPictureRecordRequest request,
        CancellationToken cancellationToken = default
    )
    {
        if (!ObjectId.TryParse(request.Id, out var oid))
        {
            return null;
        }

        var update = Builders<PictureRecord>
            .Update.Set(x => x.Category, request.Category)
            .Set(x => x.Description, request.Description)
            .Set(x => x.Tags, request.Tags);

        await repository.UpdateAsync(x => x.Id == oid, update, cancellationToken);
        if (request.Tags.Any(x => x == "banner"))
        {
            await _fusionCache.RemoveAsync(CacheKey.HomeContainerKey, token: cancellationToken);
        }

        await ClearCacheAsync();

        var entity = await repository.FindAsync(oid, cancellationToken);
        return entity == null ? null : mapper.Map<PictureRecordResponse>(entity);
    }

    public async Task DeleteAsync(string id)
    {
        var entity = await repository.TryGetAsync(id);
        if (entity == null)
        {
            return;
        }
        await repository.DeleteAsync(entity.Id);
        await mediator.Send(new RemoveImagesRequest { Images = [entity.AccessUrl] });
        await ClearCacheAsync();
    }

    public async Task ClearCacheAsync()
    {
        var removeTags = new[]
        {
            CachePrefixKey + nameof(GetTagsAsync),
            CachePrefixKey + nameof(GetPagesAsync),
            CachePrefixKey + nameof(GetBannerAsync),
            CachePrefixKey + nameof(GetPictureRecordAsync),
        };

        await _fusionCache.RemoveByTagAsync(removeTags);
    }
}