using Dpz.Core.MessageQueue.Abstractions;
using Dpz.Core.Public.ViewModel.Messages;
using Dpz.Core.Public.ViewModel.RequestEvent;

namespace Dpz.Core.Service.RepositoryServiceImpl;

public class TimelineService(
    IRepository<Timeline> repository,
    IMapper mapper,
    IMediator mediator,
    IFusionCache fusionCache,
    IMessagePublisher<DeleteMarkdownMessage> deleteMarkdownPublisher
) : AbstractCacheService(fusionCache), ITimelineService
{
    public async Task<List<VmTimeline>> GetTimelinesAsync(
        string account,
        CancellationToken cancellationToken = default
    )
    {
        return await GetOrSetCacheAsync<List<VmTimeline>>(
            nameof(GetTimelinesAsync),
            async (_, ct) =>
            {
                var list = await repository
                    .SearchFor(x => x.Author.Id == account)
                    .OrderByDescending(x => x.Date)
                    .ThenByDescending(x => x.CreateTime)
                    .ToListAsync(ct);
                return mapper.Map<List<VmTimeline>>(list);
            },
            new { account },
            cancellationToken: cancellationToken
        );
    }

    public async Task SaveAsync(VmTimeline viewModel, CancellationToken cancellationToken = default)
    {
        var entity = mapper.Map<Timeline>(viewModel);
        if (entity == null)
        {
            throw new ArgumentException("viewModel is null", nameof(viewModel));
        }

        if (entity.Id != ObjectId.Empty)
        {
            entity = await repository.TryGetAsync(
                viewModel.Id,
                cancellationToken: cancellationToken
            );
            if (entity == null)
            {
                return;
            }

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

            var update = Builders<Timeline>
                .Update.Set(x => x.Title, viewModel.Title)
                .Set(x => x.Content, viewModel.Content)
                .Set(x => x.Date, viewModel.Date)
                .Set(x => x.More, viewModel.More)
                .Set(x => x.LastUpdateTime, DateTime.Now);
            await repository.UpdateAsync(x => x.Id == entity.Id, update, cancellationToken);
            await RemoveByPrefixAsync(cancellationToken);
            return;
        }

        await repository.InsertAsync(entity, cancellationToken);
        await RemoveByPrefixAsync(cancellationToken);
    }

    public async Task DeleteAsync(string[] id, CancellationToken cancellationToken = default)
    {
        var ids = id.Select(x => ObjectId.TryParse(x, out var oid) ? oid : (ObjectId?)null)
            .Where(x => x.HasValue)
            .Select(x => x!.Value)
            .ToList();
        var filter = Builders<Timeline>.Filter.In(x => x.Id, ids);
        var list = await repository.SearchFor(filter).ToListAsync(cancellationToken);
        var contents = list.Select(x => x.Content).Where(x => !string.IsNullOrEmpty(x)).ToList();

        // 发布消息到队列，异步处理 Markdown 中的图片删除
        if (contents.Count > 0)
        {
            await deleteMarkdownPublisher.PublishAsync(
                new DeleteMarkdownMessage { MarkdownContents = contents },
                cancellationToken: cancellationToken
            );
        }

        await repository.DeleteAsync(filter, cancellationToken);
        await RemoveByPrefixAsync(cancellationToken);
    }

    public async Task<IPagedList<VmTimeline>> GetPageAsync(
        int pageIndex,
        int pageSize,
        string? content = null,
        string? account = null,
        CancellationToken cancellationToken = default
    )
    {
        return await GetOrSetPagedListAsync<VmTimeline>(
            nameof(GetPageAsync),
            async (_, _) =>
            {
                var predicate = repository.SearchFor(x => true);
                if (!string.IsNullOrEmpty(content))
                {
                    predicate = predicate.Where(x =>
                        x.Title.Contains(content) || x.Content.Contains(content)
                    );
                }

                if (!string.IsNullOrEmpty(account))
                {
                    predicate = predicate.Where(x => x.Author.Id == account);
                }

                return await predicate
                    .OrderByDescending(x => x.Date)
                    .ToPagedListAsync<Timeline, VmTimeline>(pageIndex, pageSize, cancellationToken);
            },
            new
            {
                pageIndex,
                pageSize,
                content,
                account,
            },
            cancellationToken: cancellationToken
        );
    }

    public async Task<VmTimeline?> FindAsync(
        string id,
        CancellationToken cancellationToken = default
    )
    {
        return await GetOrSetCacheAsync<VmTimeline?>(
            nameof(FindAsync),
            async (_, ct) =>
            {
                var entity = await repository.TryGetAsync(id, cancellationToken: ct);
                return entity == null ? null : mapper.Map<VmTimeline>(entity);
            },
            new { id },
            cancellationToken: cancellationToken
        );
    }

    protected override TimeSpan CacheDefaultExpiration => TimeSpan.FromDays(7);
}