using AccountsDAL.CustomCode.CostCenter;
using AccountsDAL.DTO.CostCategory;
using AccountsDAL.DTO.CostCenter;
using AccountsDAL.Query.CostCenter;
using AccountsDAL.Query.CostCenterType;
using Dapr.Client;
using GB5Shared.DaprCache;
using GB5Shared.DTO.Framework.AutoNumber;
using GB5Shared.DTO.Framework.Criteria;
using GB5Shared.DTO.Framework.HybridCache;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.EntityHandler;
using GB5Shared.GenerateAutoNumber;
using GB5Shared.PubSub.OutBox;
using GB5Shared.QueryExecutor;
using GB5Shared.Resource.Response;
using GB5Shared.ResponseStandard;
using GB5Shared.Validation;
using GB5Shared.WorkFlow.WorkFlowEngine;

using static GB5Shared.GB5Constant.Constant;

namespace AccountsBLL.CostCenter
{
    public class CostCenterBLL : ICostCenterBLL
    {
        private readonly ICostCenterDAL _CostCenterDAL;
        private readonly AutoNumber _AutoNumber;
        private readonly IValidation _Validation;
        private readonly IWorkFlowEngine _WorkFlowEngine;
        private readonly IQueryExecutor _QueryExecutor;
        private readonly DaprClient _DaprClient;
        private readonly KeyInvalidate _KeyInvalidate;
        private readonly IOutBox _OutBox;
        private readonly BaseEntityAppService<CostCenterDTO> _BaseEntityAppService;


        public CostCenterBLL(ICostCenterDAL CostCenterDAL, AutoNumber AutoNumber, IValidation validation, IQueryExecutor queryExecutor, DaprClient daprClient, KeyInvalidate keyInvalidate, IWorkFlowEngine workFlowEngine, IOutBox outBox,
       BaseEntityAppService<CostCenterDTO> baseEntityAppService)
        {
            _CostCenterDAL = CostCenterDAL;
            _AutoNumber = AutoNumber;
            _Validation = validation;
            _WorkFlowEngine = workFlowEngine;
            _QueryExecutor = queryExecutor;
            _DaprClient = daprClient;
            _KeyInvalidate = keyInvalidate;
            _OutBox = outBox;
            _BaseEntityAppService = baseEntityAppService;
        }

        public async Task<string> GetSelectListCostCenter(int FirstNumber, int MaxResult, CriteriaDTO criteriaDTO, LoginDTO loginDTO)
        {
            try
            {
                return await _CostCenterDAL.GetSelectListCostCenter(FirstNumber, MaxResult, criteriaDTO, loginDTO);
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<string> GetCostCenterList(CriteriaDTO CriteriaDTO, LoginDTO LoginDTO)
        {
            try
            {
                return await _CostCenterDAL.GetCostCenterList(CriteriaDTO, LoginDTO)
                                           .ConfigureAwait(false);
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<string> SaveCostCenter(CostCenterDTO dto, LoginDTO loginDTO, CancellationToken ct)
        {
            if (dto == null) throw new ArgumentNullException(nameof(dto));

           // dto.TenantId = loginDTO.ClientId;

            var Trans = await _QueryExecutor.BeginTransactionAsync(loginDTO);
            try
            {
                bool isNew = dto.CostCenterId == 0;

                if (isNew)
                {
                    var auto = await _AutoNumber.GetNumberAsync(1, AUTONUMBERCONSTANT.COSTCENTER, loginDTO);
                    dto.CostCenterId = auto.StartNumber;
                }

                await _BaseEntityAppService.ExecuteSaveAsync(
                    EntityConstant.OBJECTCOSTCENTER,
                    EventTypeConstant.SAVECOSTCENTEREVENTTYPEID,
                    dto,
                    loginDTO,
                    async tx =>
                    {
                        _ = isNew
                            ? await _CostCenterDAL.SaveCostCenter(dto, loginDTO, tx, ct)
                            : await _CostCenterDAL.UpdateCostCenter(dto, loginDTO, tx, ct);
                        return dto.CostCenterId;
                    },
                    null, -1, -1, Trans);

                await _QueryExecutor.CommitAsync(Trans);

                var cacheKey = CacheKeyGenerator.KeyGeneration(
                               dto.CostCenterId,                       // ✅ int parameter from method signature
                               EntityConstant.OBJECTCOSTCENTER,
                               CacheKeyLevel.CLIENT_LEVEL,
                               string.Empty,
                               loginDTO);

                await _KeyInvalidate.AllInvalidateCache(cacheKey).ConfigureAwait(false);

                return isNew
                    ? $"{SuccessResponse.SaveSuccessMessage} {dto.CostCenterId}"
                    : $"{SuccessResponse.UpdateSuccessMessage} {dto.CostCenterId}";
            }
            catch (Exception)
            {
                await _QueryExecutor.RollbackAsync(Trans);
                throw;
            }

        }

        public async Task<string> GetCostCenter(int CostCenterId, LoginDTO LoginDTO)
        {
            try
            {
                return await _CostCenterDAL.GetCostCenter(CostCenterId, LoginDTO);
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<string> DeleteCostCenter(int CostCenterId, LoginDTO LoginDTO)
              {
                    var result = await _CostCenterDAL.DeleteCostCenter(
                        CostCenterId,
                        LoginDTO);

                    var cacheKey = CacheKeyGenerator.KeyGeneration(
                        CostCenterId,
                        EntityConstant.OBJECTCOSTCENTER,
                        CacheKeyLevel.CLIENT_LEVEL,
                        string.Empty,
                        LoginDTO);

                    await _KeyInvalidate.AllInvalidateCache(cacheKey).ConfigureAwait(false);

                    return result;
        }
    }
}