using Dpz.Core.MessageQueue.Abstractions;
using Dpz.Core.Public.ViewModel.Messages;
using Dpz.Core.Public.ViewModel.Request;
using Dpz.Core.Public.ViewModel.Response;

namespace Dpz.Core.Service.RepositoryServiceImpl;

public class PictureRecordService(
    IRepository<PictureRecord> repository,
    IMapper mapper,
    IFusionCache fusionCache,
    IMessagePublisher<RemoveImagesMessage> removeImagesPublisher
) : IPictureRecordService
{
    private readonly IFusionCache _fusionCache = fusionCache;

    [Cache(ExpirationSeconds = 1 * ExpirationTime.Day)]
    public async Task<List<string>> GetTagsAsync(CancellationToken cancellationToken = default)
    {
        var tags = await repository
            .MongodbQueryable
            //.Select(x => x.Tags)
            .SelectMany(x => x.Tags)
            .GroupBy(x => x)
            .Select(x => x.Key)
            .ToListAsync(cancellationToken);
        return tags;
    }

    [Cache(ExpirationSeconds = 1 * ExpirationTime.Day)]
    public async Task<ICollection<PictureRecordResponse>> GetBannerAsync()
    {
        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;
    }

    [Cache(ExpirationSeconds = 1 * ExpirationTime.Day)]
    public async Task<IPagedList<PictureRecordResponse>> GetPagesAsync(
        List<string>? tags,
        string? description,
        int pageIndex = 1,
        int pageSize = 20,
        string? account = null,
        CancellationToken cancellationToken = default
    )
    {
        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,
                cancellationToken: cancellationToken
            );
    }

    [Cache(ExpirationSeconds = 1 * ExpirationTime.Day)]
    public async Task<PictureRecordResponse?> GetPictureRecordAsync(string id)
    {
        var entity = await repository.TryGetAsync(id);
        return entity == null ? null : mapper.Map<PictureRecordResponse>(entity);
    }

    [InvalidateCache(
        Methods = [
            nameof(GetTagsAsync),
            nameof(GetPagesAsync),
            nameof(GetBannerAsync),
            nameof(GetPictureRecordAsync),
        ]
    )]
    public async Task<PictureRecordResponse> CreateRecordAsync(
        CreatePictureRecordRequest request,
        CancellationToken cancellationToken = default
    )
    {
        var entity = mapper.Map<PictureRecord>(request);
        await repository.InsertAsync(entity, cancellationToken);
        await RemoveHomeContainerIfBannerAsync(entity.Tags, cancellationToken);
        return mapper.Map<PictureRecordResponse>(entity);
    }

    [InvalidateCache(
        Methods = [
            nameof(GetTagsAsync),
            nameof(GetPagesAsync),
            nameof(GetBannerAsync),
            nameof(GetPictureRecordAsync),
        ]
    )]
    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);
        await RemoveHomeContainerIfBannerAsync(request.Tags, cancellationToken);

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

    [InvalidateCache(
        Methods = [
            nameof(GetTagsAsync),
            nameof(GetPagesAsync),
            nameof(GetBannerAsync),
            nameof(GetPictureRecordAsync),
        ]
    )]
    public async Task DeleteAsync(string id)
    {
        var entity = await repository.TryGetAsync(id);
        if (entity == null)
        {
            return;
        }
        await repository.DeleteAsync(entity.Id);

        // 发布消息到队列，异步删除图片
        if (!string.IsNullOrEmpty(entity.AccessUrl))
        {
            await removeImagesPublisher.PublishAsync(
                new RemoveImagesMessage { ImageUrl = entity.AccessUrl }
            );
        }
    }

    [InvalidateCache(
        Methods = [
            nameof(GetTagsAsync),
            nameof(GetPagesAsync),
            nameof(GetBannerAsync),
            nameof(GetPictureRecordAsync),
        ]
    )]
    public Task ClearCacheAsync(CancellationToken cancellationToken = default)
    {
        return Task.CompletedTask;
    }

    [InvalidateCache(
        Methods = [
            nameof(GetTagsAsync),
            nameof(GetPagesAsync),
            nameof(GetBannerAsync),
            nameof(GetPictureRecordAsync),
        ]
    )]
    public async Task ClearPublishCacheAsync(
        IReadOnlyCollection<string> tags,
        CancellationToken cancellationToken = default
    )
    {
        await RemoveHomeContainerIfBannerAsync(tags, cancellationToken);
    }

    private async Task RemoveHomeContainerIfBannerAsync(
        IReadOnlyCollection<string> tags,
        CancellationToken cancellationToken = default
    )
    {
        if (tags.Any(x => string.Equals(x, "banner", StringComparison.OrdinalIgnoreCase)))
        {
            await _fusionCache.RemoveAsync(CacheKey.HomeContainerKey, token: cancellationToken);
        }
    }
}