using GB5Shared.DaprCache;
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.PartLevel;
using MMDAL.DTO.PartLevel;
using static GB5Shared.GB5Constant.Constant;

namespace MMBLL.PartLevel
{
    public class PartDimensionBLL : IPartDimensionBLL
    {
        private readonly IPartDimensionDAL                           _PartDimensionDAL;
        private readonly AutoNumber                                  _AutoNumber;
        private readonly IQueryExecutor                              _QueryExecutor;
        private readonly KeyInvalidate                               _KeyInvalidate;
        private readonly BaseEntityAppService<PartDimensionDTO>      _BaseEntityAppService;

        public PartDimensionBLL(
            IPartDimensionDAL partDimensionDAL,
            AutoNumber autoNumber,
            IQueryExecutor queryExecutor,
            KeyInvalidate keyInvalidate,
            BaseEntityAppService<PartDimensionDTO> baseEntityAppService)
        {
            _PartDimensionDAL    = partDimensionDAL;
            _AutoNumber          = autoNumber;
            _QueryExecutor       = queryExecutor;
            _KeyInvalidate       = keyInvalidate;
            _BaseEntityAppService = baseEntityAppService;
        }

        public async Task<PartDimensionDTO?> GetPartDimension(int partDimId, LoginDTO loginDTO, CancellationToken ct)
            => await _PartDimensionDAL.GetPartDimension(partDimId, loginDTO, ct).ConfigureAwait(false);

        // Returns the existing PartDimId, or creates a new row and returns the new id.
        public async Task<int> GetOrCreatePartDimension(PartDimensionDTO dto, LoginDTO loginDTO, CancellationToken ct)
        {
            int? existing = await _PartDimensionDAL.FindPartDimension(dto, loginDTO, ct).ConfigureAwait(false);
            if (existing.HasValue) return existing.Value;

            return await SavePartDimensionInternal(dto, loginDTO, ct).ConfigureAwait(false);
        }

        public async Task<string> SavePartDimension(PartDimensionDTO dto, LoginDTO loginDTO, CancellationToken ct)
        {
            await SavePartDimensionInternal(dto, loginDTO, ct).ConfigureAwait(false);
            return SuccessResponse.SaveSuccess;
        }

        public async Task<IEnumerable<PartDimensionSelectDTO>> GetSelectListPartDimension(
            LoginDTO loginDTO, CancellationToken ct)
            => await _PartDimensionDAL.GetSelectListPartDimension(loginDTO, ct).ConfigureAwait(false);

        private async Task<int> SavePartDimensionInternal(PartDimensionDTO dto, LoginDTO loginDTO, CancellationToken ct)
        {
            var Trans = await _QueryExecutor.BeginTransactionAsync(loginDTO);
            try
            {
                var auto = await _AutoNumber.GetNumberAsync(1, AUTONUMBERCONSTANT.PARTDIMENSION, loginDTO);
                dto.PartDimId = auto.StartNumber;

                await _BaseEntityAppService.ExecuteSaveAsync(
                    EntityConstant.OBJECTPARTDIMENSION,
                    EventTypeConstant.SAVEPARTDIMENSIONEVENTTYPEID,
                    dto,
                    loginDTO,
                    async tx =>
                    {
                        await _PartDimensionDAL.SavePartDimension(dto, loginDTO, tx, ct).ConfigureAwait(false);
                        return dto.PartDimId;
                    },
                    null, -1, -1, Trans);

                await _QueryExecutor.CommitAsync(Trans);

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

                return dto.PartDimId;
            }
            catch (Exception)
            {
                await _QueryExecutor.RollbackAsync(Trans);
                throw;
            }
        }
    }
}