using Dpz.Core.Public.ViewModel.RequestEvent;
using ZiggyCreatures.Caching.Fusion;

namespace Dpz.Core.Service.V4.Implements;

public class MumbleService(
    IRepository<Mumble> repository,
    IMapper mapper,
    IMediator mediator,
    IFusionCache fusionCache
) : AbstractCacheService(fusionCache), IMumbleService
{
    protected override string CachePrefixKey => "Dpz.Core.Service.V4.Implements.MumbleService";
    protected override TimeSpan CacheDefaultExpiration => TimeSpan.FromDays(3);

    private readonly IFusionCache _fusionCache = fusionCache;

    private async Task ClearCacheAsync()
    {
        var tags = new[]
        {
            CachePrefixKey + nameof(GetPagesAsync),
            CachePrefixKey + nameof(GetRandomMumblesAsync),
            CachePrefixKey + nameof(FindAsync),
        };
        await _fusionCache.RemoveByTagAsync(tags);
    }

    public async Task<VmMumble> CreateAsync(VmMumble talk)
    {
        var entity = mapper.Map<Mumble>(talk);
        await repository.InsertAsync(entity);
        await ClearCacheAsync();
        return mapper.Map<VmMumble>(entity);
    }

    public async Task<VmMumble?> EditContentAsync(VmMumble mumble)
    {
        if (mumble == null)
            throw new ArgumentNullException(nameof(mumble));
        if (mumble.Markdown == null)
            throw new ArgumentNullException(nameof(mumble.Markdown));
        if (mumble.HtmlContent == null)
            throw new ArgumentNullException(nameof(mumble.HtmlContent));

        var entity = await repository.TryGetAsync(mumble.Id);

        if (entity == null)
            return null;

        var request = new EditMarkdownRequest
        {
            Markdown = mumble.Markdown,
            OriginalMarkdown = entity.Markdown,
        };
        await mediator.Send(request);

        var update = Builders<Mumble>
            .Update.Set(x => x.HtmlContent, mumble.HtmlContent)
            .Set(x => x.Markdown, mumble.Markdown)
            .Set(x => x.LastUpdateTime, DateTime.Now);
        await repository.UpdateAsync(x => x.Id == entity.Id, update);
        await ClearCacheAsync();
        return mapper.Map<VmMumble>(await repository.FindAsync(entity.Id));
    }

    public async Task<IPagedList<VmMumble>> GetPagesAsync(
        int pageIndex,
        int pageSize,
        string? content = null,
        string? account = null
    )
    {
        return await GetOrSetPagedListAsync(
            nameof(GetPagesAsync),
            async _ =>
            {
                var predicate = repository.SearchFor(x => true);
                if (!string.IsNullOrEmpty(content))
                    predicate = predicate.Where(x => x.Markdown.Contains(content));
                if (!string.IsNullOrEmpty(account))
                    predicate = predicate.Where(x => x.Author.Id == account);

                return await predicate
                    .OrderByDescending(x => x.CreateTime)
                    .ToPagedListAsync<Mumble, VmMumble>(pageIndex, pageSize);
            },
            new
            {
                content,
                account,
                pageIndex,
                pageSize,
            }
        );
    }

    public async Task<List<VmMumble>> GetRandomMumblesAsync(int count)
    {
        return await GetOrSetCacheAsync<List<VmMumble>>(
            nameof(GetRandomMumblesAsync),
            async (_, cancellationToken) =>
            {
                var date = DateTime.Now;
                var data = await repository
                    .SearchFor(x =>
                        x.CreateTime.Month == date.Month
                        && x.CreateTime.Day == date.Day
                        && x.CreateTime.Year != date.Year
                    )
                    .Take(count)
                    .OrderByDescending(x => x.CreateTime)
                    .ToListAsync(cancellationToken);
                if (data.Count == 0)
                {
                    data = await repository.SearchFor(x => true).Sample(count).ToListAsync();
                }
                return mapper.Map<List<VmMumble>>(data);
            },
            new { count },
            x => x.SetDuration(TimeSpan.FromHours(3))
        );
    }

    public async Task<VmMumble?> FindAsync(string id)
    {
        return await GetOrSetCacheAsync<VmMumble?>(
            nameof(FindAsync),
            async (_, _) => mapper.Map<VmMumble?>(await repository.TryGetAsync(id)),
            new { id }
        );
    }

    public async Task DeleteAsync(params string[] id)
    {
        var list = await repository.TryGetListAsync(id);
        var request = new DeleteMarkdownRequest
        {
            Markdown = list.Select(x => x.Markdown).ToList(),
        };
        await mediator.Send(request);
        await repository.TryDeleteAsync(id);
        await ClearCacheAsync();
    }

    public async Task<VmMumble?> LikeAsync(string id)
    {
        var entity = await repository.TryGetAsync(id);

        if (entity is null)
            return null;

        entity.Like += 1;
        var update = Builders<Mumble>.Update.Inc(x => x.Like, 1);
        await repository.UpdateAsync(z => z.Id == entity.Id, update);
        await ClearCacheAsync();
        return mapper.Map<VmMumble>(entity);
    }
}