using AccountsDAL.CustomCode.BankBranch;
using AccountsDAL.DTO.AccountSchedule;
using AccountsDAL.DTO.BankBranch;
using AccountsDAL.DTO.CostCenter;
using AccountsDAL.DTO.CostCenterPattern;
using AccountsDAL.Query.AccountSchedule;
using AccountsDAL.Query.BankBranch;
using AccountsDAL.Query.CostCenterPattern;
using Dapr.Client;
using GB5Shared.DaprCache;
using GB5Shared.DTO.Framework.Criteria;
using GB5Shared.DTO.Framework.HybridCache;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.DTO.Qualifier;
using GB5Shared.EntityHandler;
using GB5Shared.GB5Library.Qualifier;
using GB5Shared.GenerateAutoNumber;
using GB5Shared.PubSub.OutBox;
using GB5Shared.QueryExecutor;
using GB5Shared.Resource.Response;
using GB5Shared.WorkFlow.WorkFlowEngine;
using static GB5Shared.GB5Constant.Constant;

namespace AccountsBLL.BankBranch
{
    public class BankBranchBLL : IBankBranchBLL
    {
        private readonly IBankBranchDAL  _BankBranchDAL;
        private readonly AutoNumber      _AutoNumber;
        private readonly IWorkFlowEngine _WorkFlowEngine;
        private readonly IQueryExecutor  _QueryExecutor;
        private readonly IOutBox         _OutBox;
        private readonly KeyInvalidate   _KeyInvalidate;
        private readonly DaprClient _DaprClient;
        private readonly BaseEntityAppService<BankBranchDTO> _BaseEntityAppService;

        public int BankBranchId { get; private set; }

        public BankBranchBLL(
            IBankBranchDAL  bankBranchDAL,
            AutoNumber      autoNumber,
            IWorkFlowEngine workFlowEngine,
            IQueryExecutor  queryExecutor,
            IOutBox         outBox,
            KeyInvalidate   keyInvalidate,
            DaprClient daprClient,
            BaseEntityAppService<BankBranchDTO> baseEntityAppService)
        {
            _BankBranchDAL  = bankBranchDAL;
            _AutoNumber      = autoNumber;
            _WorkFlowEngine  = workFlowEngine;
            _QueryExecutor   = queryExecutor;
            _OutBox          = outBox;
            _KeyInvalidate   = keyInvalidate;
            _DaprClient = daprClient;
            _BaseEntityAppService = baseEntityAppService;
        }

        public async Task<string> GetBankBranch(int bankBranchId, LoginDTO loginDTO)
        {
            try
            {
                return await _BankBranchDAL.GetBankBranch(bankBranchId, loginDTO)
                                           .ConfigureAwait(false);
            }
            catch (Exception)
            {
                throw;
            }
        }

        //public async Task<string> SaveBankBranch(BankBranchDTO dto, LoginDTO loginDTO, CancellationToken ct)
        //{
        //    var Trans = await _QueryExecutor.BeginTransactionAsync(loginDTO);
        //    dto.TenantId = loginDTO.ClientId;
        //    try
        //    {
        //        bool isNew = dto.BankBranchId == 0;

        //        if (isNew)
        //        {
        //            var auto = await _AutoNumber.GetNumberAsync(1, AUTONUMBERCONSTANT.BANKBRANCH, loginDTO)
        //                                       .ConfigureAwait(false);
        //            dto.BankBranchId = auto.StartNumber;
        //        }

        //        //var definitions = new List<QualifierDefinitionDTO>();
        //        //var executors   = new List<IQualifierExecutor>();
        //        //var engine      = new QualifierEngine((IQualifierDefinitionLoader)definitions, executors);
        //        //var facade      = new QualifierFacade(engine);
        //        //var baseSvc     = new BaseEntityAppService<BankBranchDTO>(
        //        //    facade, _WorkFlowEngine, _OutBox, _QueryExecutor, _DaprClient);

        //        await _BaseEntityAppService.ExecuteSaveAsync(
        //            EntityConstant.OBJECTBANKBRANCH,
        //            EventTypeConstant.SAVEBANKBRANCHEVENTTYPEID,
        //            dto,
        //            loginDTO,
        //            async tx =>
        //            {
        //                if (isNew)
        //                    await _BankBranchDAL.SaveBankBranch(dto, loginDTO, tx).ConfigureAwait(false);
        //                else
        //                    await _BankBranchDAL.UpdateBankBranch(dto, loginDTO, tx).ConfigureAwait(false);
        //                return dto.BankBranchId;
        //            },
        //            null, -1, -1, Trans);

        //        await _QueryExecutor.CommitAsync(Trans);

        //        var cacheKey = CacheKeyGenerator.KeyGeneration(
        //                         dto.BankBranchId,                // ← property from the dto instance
        //                         EntityConstant.OBJECTBANKBRANCH,
        //                         CacheKeyLevel.CLIENT_LEVEL,
        //                         string.Empty,
        //                         loginDTO);
        //       // await _KeyInvalidate.AllInvalidateCache(cacheKey);

        //        return isNew ? SuccessResponse.SaveSuccess : SuccessResponse.UpdateSuccess;
        //    }
        //    catch (Exception)
        //    {
        //        await _QueryExecutor.RollbackAsync(Trans);
        //        throw;
        //    }
        //}
        public async Task<string> SaveBankBranch(BankBranchDTO 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.BankBranchId == 0;

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

                await _BaseEntityAppService.ExecuteSaveAsync(
                    EntityConstant.OBJECTBANKBRANCH,
                     EventTypeConstant.SAVEBANKBRANCHEVENTTYPEID,
                    dto,
                    loginDTO,
                    async tx =>
                    {
                        _ = isNew
                            ? await _BankBranchDAL.SaveBankBranch(dto, loginDTO, tx, ct)
                            : await _BankBranchDAL.UpdateBankBranch(dto, loginDTO, tx, ct);
                        return dto.BankBranchId;
                    },
                    null, -1, -1, Trans);

                await _QueryExecutor.CommitAsync(Trans);

                var cacheKey = CacheKeyGenerator.KeyGeneration(
                                BankBranchId,                       // ✅ int parameter from method signature
                                EntityConstant.OBJECTBANKBRANCH,
                                CacheKeyLevel.CLIENT_LEVEL,
                                string.Empty,
                                loginDTO);
                await _KeyInvalidate.AllInvalidateCache(cacheKey);


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

        }
        public async Task<string> DeleteBankBranch(int BankBranchId, LoginDTO loginDTO)
        {
            var Trans = await _QueryExecutor.BeginTransactionAsync(loginDTO);
            try
            {
                //var definitions = new List<QualifierDefinitionDTO>();
                //var executors   = new List<IQualifierExecutor>();
                //var engine      = new QualifierEngine((IQualifierDefinitionLoader)definitions, executors);
                //var facade      = new QualifierFacade(engine);
                //var baseSvc = new BaseEntityAppService<AccountGroupDTO>(  // ✅ correct generic
                //                    facade, _WorkFlowEngine, _OutBox, _QueryExecutor, _DaprClient);

                await _BaseEntityAppService.ExecuteSaveAsync(
                    EntityConstant.OBJECTBANKBRANCH,
                     EventTypeConstant.DELETEBANKBRANCHEVENTTYPEID,
                    new BankBranchDTO { BankBranchId = BankBranchId
                        //TenantId = loginDTO.ClientId
                    },
                    loginDTO,
                    async tx =>
                    {
                        await _BankBranchDAL.DeleteBankBranch(BankBranchId, loginDTO, tx)
                                              .ConfigureAwait(false);
                        return BankBranchId;
                    },
                    null, -1, -1, Trans);

                await _QueryExecutor.CommitAsync(Trans);

                var cacheKey = CacheKeyGenerator.KeyGeneration(
                                 BankBranchId,                       // ✅ int parameter from method signature
                                 EntityConstant.OBJECTBANKBRANCH,
                                 CacheKeyLevel.CLIENT_LEVEL,
                                 string.Empty,
                                 loginDTO);
                await _KeyInvalidate.AllInvalidateCache(cacheKey);

                return SuccessResponse.DeleteSuccessMessage;
            }
            catch (Exception)
            {
                await _QueryExecutor.RollbackAsync(Trans);
                throw;
            }
        }
        

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

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