using GB5Shared.DaprCache;
using GB5Shared.DTO.Framework.Criteria;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.EntityHandler;
using GB5Shared.GB5Library.Qualifier;
using GB5Shared.GenerateAutoNumber;
using GB5Shared.QueryExecutor;
using GB5Shared.Resource.Response;
using MMDAL.CustomCode.MRP;
using MMDAL.DTO.MRP;
using static GB5Shared.GB5Constant.Constant;

namespace MMBLL.MRP
{
    public class MRPBLL : IMRPBLL
    {
        private readonly IMRPDAL                        _MRPDAL;
        private readonly AutoNumber                     _AutoNumber;
        private readonly IQueryExecutor                 _QueryExecutor;
        private readonly KeyInvalidate                  _KeyInvalidate;
        private readonly BaseEntityAppService<MRPDTO>   _BaseEntityAppService;

        public MRPBLL(
            IMRPDAL mrpDAL,
            AutoNumber autoNumber,
            IQueryExecutor queryExecutor,
            KeyInvalidate keyInvalidate,
            BaseEntityAppService<MRPDTO> baseEntityAppService)
        {
            _MRPDAL               = mrpDAL;
            _AutoNumber           = autoNumber;
            _QueryExecutor        = queryExecutor;
            _KeyInvalidate        = keyInvalidate;
            _BaseEntityAppService = baseEntityAppService;
        }

        // ── Get single record ─────────────────────────────────────────────

        public async Task<MRPDTO?> GetMRP(int mrpId, LoginDTO loginDTO)
        {
            return await _MRPDAL.GetMRP(mrpId, loginDTO).ConfigureAwait(false);
        }

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

        public async Task<string> SaveMRP(MRPDTO dto, LoginDTO loginDTO)
        {
            if (dto is null) throw new ArgumentNullException(nameof(dto));
            if (string.IsNullOrWhiteSpace(dto.MRPCode))
                throw new ArgumentException("MRP Code is required.");
            if (string.IsNullOrWhiteSpace(dto.MRPName))
                throw new ArgumentException("MRP Name is required.");

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

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

                await _BaseEntityAppService.ExecuteSaveAsync(
                    EntityConstant.OBJECTMRP,
                    EventTypeConstant.SAVEMRPEVENTTYPEID,
                    dto,
                    loginDTO,
                    async tx =>
                    {
                        var result = isNew
                            ? await _MRPDAL.SaveMRP(dto, loginDTO, tx)
                            : await _MRPDAL.UpdateMRP(dto, loginDTO, tx);

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

                await _QueryExecutor.CommitAsync(Trans);

                //var cacheKey = KeyGenerator.KeyGeneration(
                //    dto.MRPId,
                //    EntityConstant.OBJECTMRP,
                //    CacheKeyLevel.CLIENT_LEVEL,
                //    loginDTO);
                //await _KeyInvalidate.AllInvalidateCache(cacheKey);

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

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

        public async Task<string> DeleteMRP(int mrpId, LoginDTO loginDTO)
        {
            var Trans = await _QueryExecutor.BeginTransactionAsync(loginDTO);
            try
            {
                await _BaseEntityAppService.ExecuteSaveAsync(
    EntityConstant.OBJECTMRP,
    EventTypeConstant.DELETEMRPEVENTTYPEID,
    new MRPDTO { MRPId = mrpId },
    loginDTO,
    async tx =>
    {
        await _MRPDAL.DeleteMRP(mrpId, loginDTO, tx);
        return mrpId;
    },
    null,
    -1,
    -1,
    Trans);

                await _QueryExecutor.CommitAsync(Trans);

                //var cacheKey = KeyGenerator.KeyGeneration(
                //    mrpId,
                //    EntityConstant.OBJECTMRP,
                //    CacheKeyLevel.CLIENT_LEVEL,
                //    loginDTO);
                //await _KeyInvalidate.AllInvalidateCache(cacheKey);

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

        // ── Paged list ────────────────────────────────────────────────────

        public async Task<IEnumerable<MRPListDTO>> GetMRPList(
            int pageOffset, int pageSize, LoginDTO loginDTO)
        {
            return await _MRPDAL.GetMRPList(pageOffset, pageSize, loginDTO)
                .ConfigureAwait(false);
        }

        // ── Picklist ──────────────────────────────────────────────────────

        public async Task<IEnumerable<MRPPicklistDTO>> GetSelectListMRP(CriteriaDTO criteriaDTO, LoginDTO loginDTO)
        {
            return await _MRPDAL.GetSelectListMRP(criteriaDTO, loginDTO).ConfigureAwait(false);
        }
    }
}