using AccountsDAL.CustomCode.DeferalPlan;
using AccountsDAL.DTO.CostCenter;
using AccountsDAL.DTO.DeferalPlan;
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.DeferalPlan
{
    public class DeferalPlanBLL : IDeferalPlanBLL
    {
        private readonly IDeferalPlanDAL _DeferalPlanDAL;
        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<DeferalPlanDTO> _BaseEntityAppService;
        public DeferalPlanBLL(
            IDeferalPlanDAL deferralPlanDAL,
            AutoNumber      autoNumber,
            IWorkFlowEngine workFlowEngine,
            IQueryExecutor  queryExecutor,
            IOutBox         outBox,
            KeyInvalidate   keyInvalidate,
             DaprClient daprClient,
             BaseEntityAppService<DeferalPlanDTO> baseEntityAppService)
        {
            _DeferalPlanDAL = deferralPlanDAL;
            _AutoNumber      = autoNumber;
            _WorkFlowEngine  = workFlowEngine;
            _QueryExecutor   = queryExecutor;
            _OutBox          = outBox;
            _KeyInvalidate   = keyInvalidate;
            _DaprClient = daprClient;
            _BaseEntityAppService = baseEntityAppService;
        }

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

        public async Task<string> SaveDeferalPlan(DeferalPlanDTO dto, LoginDTO loginDTO)
        {
            var Trans = await _QueryExecutor.BeginTransactionAsync(loginDTO);
            try
            {
                bool isNew = dto.DeferalPlanId == 0;

                if (isNew)
                {
                    var auto = await _AutoNumber.GetNumberAsync(1, AUTONUMBERCONSTANT.DEFERALPLAN, loginDTO)
                                               .ConfigureAwait(false);
                    dto.DeferalPlanId = 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<DeferalPlanDTO>(
                //    facade, _WorkFlowEngine, _OutBox, _QueryExecutor, _DaprClient);

                await _BaseEntityAppService.ExecuteSaveAsync(
                    EntityConstant.OBJECTDEFERALPLAN,
                    EventTypeConstant.SAVEDEFERALPLANEVENTTYPEID,
                    dto,
                    loginDTO,
                    async tx =>
                    {
                        if (isNew)
                            await _DeferalPlanDAL.SaveDeferalPlan(dto, loginDTO, tx).ConfigureAwait(false);
                        else
                            await _DeferalPlanDAL.UpdateDeferalPlan(dto, loginDTO, tx).ConfigureAwait(false);
                        return dto.DeferalPlanId;
                    },
                    null, -1, -1, Trans);

                await _QueryExecutor.CommitAsync(Trans);

                var cacheKey = CacheKeyGenerator.KeyGeneration(
                                     dto.DeferalPlanId,
                                     EntityConstant.OBJECTDEFERALPLAN,
                                     CacheKeyLevel.CLIENT_LEVEL,
                                     string.Empty,                     // ← SourceData
                                     loginDTO);
              await _KeyInvalidate.AllInvalidateCache(cacheKey);

                return isNew ? SuccessResponse.SaveSuccess : SuccessResponse.UpdateSuccess;
            }
            catch (Exception)
            {
                await _QueryExecutor.RollbackAsync(Trans);
                throw;
            }
        }

        //public async Task<string> DeleteDeferalPlan(int deferralPlanId, 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<DeferalPlanDTO>(
        //        //    facade, _WorkFlowEngine, _OutBox, _QueryExecutor, _DaprClient);

        //        //await _BaseEntityAppService.ExecuteSaveAsync(
        //        //    EntityConstant.OBJECTDEFERALPLAN,
        //        //    EventTypeConstant.DELETEDEFERALPLANEVENTTYPEID,
        //        //    new DeferalPlanDTO { DeferalPlanId = deferralPlanId,
        //        //        TenantId = loginDTO.ClientId
        //        //    },
        //        //    loginDTO,
        //        //    async tx =>
        //        //  //  {
        //                await _DeferalPlanDAL.DeleteDeferalPlan(deferralPlanId, loginDTO)
        //                                     .ConfigureAwait(false);
        //                return deferralPlanId;
        //            //},
        //            //null, -1, -1, Trans);

        //        await _QueryExecutor.CommitAsync(Trans);

        //        var cacheKey = CacheKeyGenerator.KeyGeneration(
        //                        deferralPlanId,
        //                        EntityConstant.OBJECTDEFERALPLAN,
        //                        CacheKeyLevel.CLIENT_LEVEL,
        //                        string.Empty,                     // ← SourceData
        //                        loginDTO);
        //        //await _KeyInvalidate.AllInvalidateCache(cacheKey);

        //        return SuccessResponse.DeleteSuccessMessage;
        //    }
        //    catch (Exception)
        //    {
        //        await _QueryExecutor.RollbackAsync(Trans);
        //        throw;
        //    }
        //}
        public async Task<string> DeleteDeferalPlan(
              int deferralPlanId,
              LoginDTO loginDTO)
        {
            var Trans = await _QueryExecutor.BeginTransactionAsync(loginDTO);

            try
            {
                await _DeferalPlanDAL
                    .DeleteDeferalPlan(deferralPlanId, loginDTO, Trans)
                    .ConfigureAwait(false);

                await _QueryExecutor.CommitAsync(Trans);

                var cacheKey = CacheKeyGenerator.KeyGeneration(
                    deferralPlanId,
                    EntityConstant.OBJECTDEFERALPLAN,
                    CacheKeyLevel.CLIENT_LEVEL,
                    string.Empty,
                    loginDTO);

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

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

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