using Dpz.Core.Entity.Base.PublicStruct;
using Dpz.Core.Public.ViewModel.Request;
using Dpz.Core.Public.ViewModel.Response;

namespace Dpz.Core.Service.RepositoryServiceImpl;

/// <summary>
/// 拦截规则管理。读走 [Cache]，写后由装饰器失效，判定端下次 GetAllAsync 即读到新规则
/// </summary>
public class InterceptRuleAdminService(IRepository<InterceptRule> repository, IMapper mapper)
    : IInterceptRuleAdminService
{
    /// <inheritdoc />
    [Cache(ExpirationSeconds = ExpirationTime.Month)]
    public async Task<List<InterceptRuleResponse>> GetAllAsync(
        CancellationToken cancellationToken = default
    )
    {
        var rules = await repository.SearchFor(_ => true).ToListAsync(cancellationToken);
        return mapper.Map<List<InterceptRuleResponse>>(rules);
    }

    /// <inheritdoc />
    [InvalidateCache(Methods = [nameof(GetAllAsync)])]
    public async Task AddAsync(
        InterceptRuleSaveRequest request,
        CancellationToken cancellationToken = default
    )
    {
        ValidateRequest(request);

        var entity = new InterceptRule
        {
            Type = request.Type,
            Pattern = request.Pattern,
            Key = request.Key,
        };
        await repository.InsertAsync(entity, cancellationToken);
    }

    /// <inheritdoc />
    [InvalidateCache(Methods = [nameof(GetAllAsync)])]
    public async Task UpdateAsync(
        InterceptRuleEditRequest request,
        CancellationToken cancellationToken = default
    )
    {
        ValidateRequest(request);

        if (!ObjectId.TryParse(request.Id, out var oid))
        {
            throw new ArgumentException($"非法的拦截规则标识: {request.Id}");
        }

        var entity = await repository.FindAsync(oid, cancellationToken);
        if (entity == null)
        {
            throw new InvalidOperationException($"拦截规则不存在: {request.Id}");
        }

        entity.Type = request.Type;
        entity.Pattern = request.Pattern;
        entity.Key = request.Key;
        await repository.UpdateAsync(entity, cancellationToken);
    }

    /// <inheritdoc />
    [InvalidateCache(Methods = [nameof(GetAllAsync)])]
    public async Task DeleteAsync(string id, CancellationToken cancellationToken = default)
    {
        if (!ObjectId.TryParse(id, out var oid))
        {
            throw new ArgumentException($"非法的拦截规则标识: {id}");
        }

        await repository.DeleteAsync(oid, cancellationToken);
    }

    /// <summary>
    /// 校验入参
    /// </summary>
    private static void ValidateRequest(InterceptRuleSaveRequest request)
    {
        if (string.IsNullOrWhiteSpace(request.Pattern))
        {
            throw new ArgumentException("拦截规则匹配模式不能为空");
        }

        if (!Enum.IsDefined(request.Type))
        {
            throw new ArgumentException($"非法的拦截类型: {request.Type}");
        }

        if (
            request.Type is InterceptType.Header or InterceptType.QueryParameter
            && string.IsNullOrWhiteSpace(request.Key)
        )
        {
            throw new ArgumentException("Header 与 QueryParameter 类型必须指定键名");
        }
    }
}