namespace Dpz.Core.Service.RepositoryServiceImpl;

public class BlockService(IRepository<Block> repository, IMapper mapper) : IBlockService
{
    /// <inheritdoc />
    public async Task SaveBlockAsync(Block block)
    {
        var entity = await repository
            .SearchFor(x =>
                x.RequestMethod == block.RequestMethod && x.RequestPath == block.RequestPath
            )
            .FirstOrDefaultAsync();
        if (entity != null)
        {
            var updates = new List<UpdateDefinition<Block>>
            {
                Builders<Block>.Update.Inc(x => x.AccessCount, 1),
            };
            var pushIpAddresses = block.IpAddresses.Except(entity.IpAddresses).ToList();
            if (pushIpAddresses.Count > 0)
            {
                updates.Add(Builders<Block>.Update.PushEach(x => x.IpAddresses, pushIpAddresses));
            }

            var pushUserAgents = block.UserAgents.Except(entity.UserAgents).ToList();
            if (pushUserAgents.Count > 0)
            {
                updates.Add(Builders<Block>.Update.PushEach(x => x.UserAgents, pushUserAgents));
            }

            await repository.UpdateAsync(
                x => x.Id == entity.Id,
                Builders<Block>.Update.Combine(updates)
            );
            return;
        }

        if (block.AccessCount <= 0)
        {
            block.AccessCount = 1;
        }
        await repository.InsertAsync(block);
    }

    /// <inheritdoc />
    public async Task IncrementCountAsync(string method, string requestPath)
    {
        var block = await repository
            .SearchFor(x => x.RequestMethod == method && x.RequestPath == requestPath)
            .FirstOrDefaultAsync();
        if (block == null)
        {
            await SaveBlockAsync(new Block { RequestMethod = method, RequestPath = requestPath });
            return;
        }

        var update = Builders<Block>.Update.Inc(x => x.AccessCount, 1);
        await repository.UpdateAsync(x => x.Id == block.Id, update);
    }

    /// <inheritdoc />
    [Cache(ExpirationSeconds = 3 * ExpirationTime.Hour)]
    public async Task<List<VmBlock>> GetBlocksAsync(int? minAccess = null)
    {
        var minAccessValue = minAccess ?? 0;
        var list = await repository.SearchFor(x => x.AccessCount >= minAccessValue).ToListAsync();
        return mapper.Map<List<VmBlock>>(list);
    }

    /// <inheritdoc />
    [InvalidateCache(Methods = [nameof(GetBlocksAsync)])]
    public async Task DeleteAsync(string id, CancellationToken cancellationToken = default)
    {
        if (!ObjectId.TryParse(id, out var oid))
        {
            return;
        }

        await repository.DeleteAsync(oid, cancellationToken);
    }
}