using AMPBLL.ServiceCapability;
using AmpDAL.CustomCode.ApiCapability;
using AMPDAL.DTO.ApiCapability;
using GB5Shared.DaprCache;
using GB5Shared.DTO.Framework.Criteria;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.EventLogPublish;
using GB5Shared.GB5Constant;
using GB5Shared.GenerateAutoNumber;
using GB5Shared.Resource.Response;
using GB5Shared.Validation;
using Microsoft.Extensions.Logging;

namespace AMPBLL.ApiCapability;

public class ApiCapabilityBLL(
    IApiCapabilityDAL         _dal,
    IValidation               _validation,
    KeyInvalidate             _keyInvalidate,
    EventLogPublish           _eventLog,
    AutoNumber                _autoNumber,
    ILogger<ApiCapabilityBLL> _logger
) : IApiCapabilityBLL
{
    public async Task<ApiCapabilityDTO?> GetCapabilityAsync(long apiCapabilityId, LoginDTO login, CancellationToken ct)
        => await _dal.GetCapabilityAsync(apiCapabilityId, login.ClientId, login, ct).ConfigureAwait(false);

    public async Task<List<ApiCapabilityDTO>> GetCapabilitySelectListAsync(CriteriaDTO criteriaDTO, LoginDTO login, CancellationToken ct)
        => await _dal.GetCapabilitySelectListAsync(criteriaDTO, login, ct).ConfigureAwait(false);

    public async Task<List<ApiCapabilityDTO>> GetCapabilityList(int firstNumber, int maxResult, CriteriaDTO criteriaDTO, LoginDTO login, CancellationToken ct)
    {
        if (firstNumber == -1 && maxResult == -1)
            return await _dal.GetCapabilityListAsync(criteriaDTO, login, ct).ConfigureAwait(false);

        return await _dal.GetPagedCapabilityList(firstNumber, maxResult, login, ct).ConfigureAwait(false);
    }

    public async Task<string> SaveCapabilityAsync(ApiCapabilitySaveDTO dto, LoginDTO login, CancellationToken ct)
    {
        if (dto == null) throw new ArgumentNullException(nameof(dto));

        await _validation.NotEmpty(dto.CapabilityName, nameof(dto.CapabilityName));

        dto.TenantId = login.ClientId;

        bool isNew = dto.ApiCapabilityId == 0;
        long capabilityId;

        if (isNew)
        {
            var autoNumberDTO = await _autoNumber.GetAutoNumber(1, "APICAPABILITY", login);
            dto.ApiCapabilityId = autoNumberDTO.StartNumber;
            capabilityId = await _dal.SaveCapabilityAsync(dto, login, ct).ConfigureAwait(false);
        }
        else
        {
            capabilityId = await _dal.UpdateCapabilityAsync(dto, login, ct).ConfigureAwait(false);
        }

        var cacheKey = new CacheKeyGeneration().KeyGeneration(
            login.ClientId.ToString(),
            Constant.EntityConstant.OBJECTAMPCAPABILITY,
            Constant.CacheKeyLevel.CLIENT_LEVEL,
            login);
        try { await _keyInvalidate.InvalidateCache(cacheKey); }
        catch (Exception ex) { _logger.LogWarning(ex, "Dapr cache invalidation failed for Capability {CapabilityId}", capabilityId); }

        try
        {
            await _eventLog.PublishEventLogAsync(
                isNew ? "AMP Capability Created" : "AMP Capability Updated",
                new { dto.CapabilityName, CapabilityId = capabilityId },
                Constant.EventTypeConstant.SAVEDOCUMENTSET,
                0,
                login).ConfigureAwait(false);
        }
        catch (Exception ex) { _logger.LogWarning(ex, "Dapr event publish failed for Capability {CapabilityId}", capabilityId); }

        return isNew
            ? $"{SuccessResponse.SaveSuccessMessage} {capabilityId}"
            : $"{SuccessResponse.UpdateSuccessMessage} {capabilityId}";
    }

    public async Task<string> SaveCapabilityLinkAsync(long apiId, long apiCapabilityId, int apiCapabilityLinkId, LoginDTO login, CancellationToken ct)
    {
        if (apiId == 0) throw new ArgumentException("ApiId must be greater than zero.", nameof(apiId));
        if (apiCapabilityId == 0) throw new ArgumentException("ApiCapabilityId must be greater than zero.", nameof(apiCapabilityId));

        var dto = new SaveApiCapabilityLinkDTO
        {
            SourceType = 5,
            ApiId = (int)apiId,
            ApiCapabilityId = (int)apiCapabilityId,
            ApiCapabilityLinkId = apiCapabilityLinkId,
            TenantId = login.ClientId
        };

        bool isNew = dto.ApiCapabilityLinkId == 0;
        var now = DateTime.UtcNow;

        if (isNew)
        {
            var autoNumberDTO = await _autoNumber.GetAutoNumber(1, "APICAPABILITYLINK", login);
            dto.ApiCapabilityLinkId = autoNumberDTO.StartNumber;
            dto.CreatedById = login.UserId;
            dto.CreatedOn = now;
            dto.ModifiedById = login.UserId;
            dto.ModifiedOn = now;
            await _dal.SaveCapabilityLinkAsync(dto, login, ct).ConfigureAwait(false);
        }
        else
        {
            dto.ModifiedById = login.UserId;
            dto.ModifiedOn = now;
            await _dal.UpdateCapabilityLinkAsync(dto, login, ct).ConfigureAwait(false);
        }

        var cacheKey = new CacheKeyGeneration().KeyGeneration(
            login.ClientId.ToString(),
            Constant.EntityConstant.OBJECTAMPCAPABILITYLINK,
            Constant.CacheKeyLevel.CLIENT_LEVEL,
            login);
        try { await _keyInvalidate.InvalidateCache(cacheKey); }
        catch (Exception ex) { _logger.LogWarning(ex, "Dapr cache invalidation failed for CapabilityLink {LinkId}", dto.ApiCapabilityLinkId); }

        try
        {
            await _eventLog.PublishEventLogAsync(
                isNew ? "AMP Capability Link Created" : "AMP Capability Link Updated",
                new { dto.ApiId, dto.ApiCapabilityId, ApiCapabilityLinkId = dto.ApiCapabilityLinkId },
                Constant.EventTypeConstant.SAVEDOCUMENTSET,
                0,
                login).ConfigureAwait(false);
        }
        catch (Exception ex) { _logger.LogWarning(ex, "Dapr event publish failed for CapabilityLink {LinkId}", dto.ApiCapabilityLinkId); }

        return isNew
            ? $"{SuccessResponse.SaveSuccessMessage} {dto.ApiCapabilityLinkId}"
            : $"{SuccessResponse.UpdateSuccessMessage} {dto.ApiCapabilityLinkId}";
    }

    public async Task<string> DeleteById(int apiCapabilityId, LoginDTO login, CancellationToken ct)
    {
        await _dal.DeleteById(apiCapabilityId, login, ct).ConfigureAwait(false);
        return SuccessResponse.DeleteSuccessMessage;
    }
}