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

namespace Dpz.Core.Service.RepositoryServiceImpl;

public class BarrageService(
    IRepository<Barrage> repository,
    IMapper mapper,
    IMessagePublisher<AddDanmakuCountMessage> addDanmakuCountPublisher
) : IBarrageService
{
    public async Task<List<VmBarrage>> GetGroupBarragesAsync(string @group)
    {
        var list = await repository
            .SearchFor(x => x.Group == group)
            .OrderByDescending(x => x.SendTime)
            .Take(2000)
            .ToListAsync();
        return mapper.Map<List<VmBarrage>>(list);
    }

    public async Task<int> GetGroupBarrageCountAsync(string groupValue)
    {
        var count = await repository.SearchFor(x => x.Group == groupValue).CountAsync();
        return count;
    }

    public async Task AddBarrageAsync(VmBarrage viewModel)
    {
        var barrage = mapper.Map<Barrage>(viewModel);
        await repository.InsertAsync(barrage);
        // 发布消息到队列，异步更新弹幕计数
        await addDanmakuCountPublisher.PublishAsync(
            new AddDanmakuCountMessage { DanmakuGroup = barrage.Group }
        );
    }

    public async Task<IPagedList<VmBarrage>> GetPageAsync(
        int pageIndex,
        int pageSize,
        string? text = "",
        string? @group = ""
    )
    {
        var predicate = repository.SearchFor(x => true);
        if (!string.IsNullOrEmpty(text))
        {
            predicate = predicate.Where(x => x.Text.Contains(text));
        }

        if (!string.IsNullOrEmpty(group))
        {
            predicate = predicate.Where(x => x.Group == group);
        }
        return await predicate
            .OrderByDescending(x => x.Id)
            .ToPagedListAsync<Barrage, VmBarrage>(pageIndex, pageSize);
    }

    public async Task DeleteAsync(params string[] id)
    {
        await repository.TryDeleteAsync(id);
    }

    public async Task<List<string>> GetGroupsAsync()
    {
        return await repository
            .SearchFor(x => true)
            .GroupBy(x => x.Group)
            .Select(x => x.Key)
            .OrderBy(x => x)
            .ToListAsync();
    }

    public async Task ImportAsync(params VmBarrage[] barrages)
    {
        if (barrages.Any())
        {
            var source = mapper.Map<Barrage[]>(barrages);
            await repository.InsertAsync(source);
        }
    }
}