using GB5Shared.DaprCache;
using GB5Shared.DTO.Framework.HybridCache;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.EntityHandler;
using GB5Shared.GenerateAutoNumber;
using GB5Shared.QueryExecutor;
using GB5Shared.Resource.Response;
using MMDAL.CustomCode.Scheduling;
using MMDAL.DTO.Scheduling;
using static GB5Shared.GB5Constant.Constant;

namespace MMBLL.Scheduling
{
    public class BatchRuleBLL : IBatchRuleBLL
    {
        private readonly IBatchRuleDAL                    _BatchRuleDAL;
        private readonly AutoNumber                        _AutoNumber;
        private readonly IQueryExecutor                    _QueryExecutor;
        private readonly KeyInvalidate                     _KeyInvalidate;
        private readonly BaseEntityAppService<BatchRuleDTO> _BaseEntityAppService;

        public BatchRuleBLL(
            IBatchRuleDAL batchRuleDAL,
            AutoNumber autoNumber,
            IQueryExecutor queryExecutor,
            KeyInvalidate keyInvalidate,
            BaseEntityAppService<BatchRuleDTO> baseEntityAppService)
        {
            _BatchRuleDAL        = batchRuleDAL;
            _AutoNumber          = autoNumber;
            _QueryExecutor       = queryExecutor;
            _KeyInvalidate       = keyInvalidate;
            _BaseEntityAppService = baseEntityAppService;
        }

        // ── Reads ─────────────────────────────────────────────────────────

        public async Task<BatchRuleDTO?> GetBatchRule(
            int batchRuleId, LoginDTO loginDTO, CancellationToken ct = default)
        {
            try
            {
                return await _BatchRuleDAL
                    .GetBatchRule(batchRuleId, loginDTO, ct)
                    .ConfigureAwait(false);
            }
            catch (Exception) { throw; }
        }

        public async Task<IEnumerable<BatchRuleDTO>> GetBatchRuleList(
            int workCenterId, LoginDTO loginDTO, CancellationToken ct = default)
        {
            try
            {
                return await _BatchRuleDAL
                    .GetBatchRuleList(workCenterId, loginDTO, ct)
                    .ConfigureAwait(false);
            }
            catch (Exception) { throw; }
        }

        public async Task<BatchRuleDTO?> GetBatchRuleForProcess(
            int workCenterId, int processId, LoginDTO loginDTO, CancellationToken ct = default)
        {
            try
            {
                return await _BatchRuleDAL
                    .GetBatchRuleForProcess(workCenterId, processId, loginDTO, ct)
                    .ConfigureAwait(false);
            }
            catch (Exception) { throw; }
        }

        // ── Save (insert or update) ───────────────────────────────────────

        public async Task<string> SaveBatchRule(BatchRuleDTO dto, LoginDTO loginDTO)
        {
            if (dto == null) throw new ArgumentNullException(nameof(dto));

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

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

                await _BaseEntityAppService.ExecuteSaveAsync(
                    EntityConstant.OBJECTBATCHRULE,
                    EventTypeConstant.SAVEBATCHRULEEVENTTYPEID,
                    dto,
                    loginDTO,
                    async tx =>
                    {
                        var result = isNew
                            ? await _BatchRuleDAL.SaveBatchRule(dto, loginDTO, tx)
                            : await _BatchRuleDAL.UpdateBatchRule(dto, loginDTO, tx);

                        return dto.BatchRuleId;
                    },
                    null, -1, -1, Trans);

                await _QueryExecutor.CommitAsync(Trans);

                var cacheKey = CacheKeyGenerator.KeyGeneration(
                    dto.BatchRuleId,
                    EntityConstant.OBJECTBATCHRULE,
                    CacheKeyLevel.CLIENT_LEVEL,null!,
                    loginDTO );
                await _KeyInvalidate.AllInvalidateCache(cacheKey);

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

        // ── Delete ────────────────────────────────────────────────────────

        public async Task<string> DeleteBatchRule(int batchRuleId, LoginDTO loginDTO)
        {
            var Trans = await _QueryExecutor.BeginTransactionAsync(loginDTO);
            try
            {
                await _BaseEntityAppService.ExecuteSaveAsync(
                    EntityConstant.OBJECTBATCHRULE,
                    EventTypeConstant.DELETEBATCHRULEEVENTTYPEID,
                    new BatchRuleDTO { BatchRuleId = batchRuleId },
                    loginDTO,
                    async tx => { await _BatchRuleDAL.DeleteBatchRule(batchRuleId, loginDTO, tx); return batchRuleId; },
                    null, -1, -1, Trans);

                await _QueryExecutor.CommitAsync(Trans);

                var cacheKey = CacheKeyGenerator.KeyGeneration(
                    batchRuleId,
                    EntityConstant.OBJECTBATCHRULE,
                    CacheKeyLevel.CLIENT_LEVEL,null!,
                    loginDTO);
                await _KeyInvalidate.AllInvalidateCache(cacheKey);

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