using GB5Shared.DTO.Framework.Criteria;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.GenerateAutoNumber;
using GB5Shared.QueryExecutor;
using GB5Shared.Resource.Response;
using MMDAL.CustomCode.Packing;
using MMDAL.DTO.Packing;
using Newtonsoft.Json;
using static GB5Shared.GB5Constant.Constant;

namespace MMBLL.Packing
{
    public class PackingBLL : IPackingBLL
    {
        private readonly IPackingDAL _PackingDAL;
        private readonly AutoNumber _autoNumber;
        private readonly IQueryExecutor _qe;

        public PackingBLL(IPackingDAL PackingDAL, AutoNumber autoNumber, IQueryExecutor qe)
        {
            _PackingDAL = PackingDAL;
            _autoNumber = autoNumber;
            _qe = qe;
        }

        public async Task<string> GetSelectListPacking(int FirstNumber, int MaxResult, CriteriaDTO CriteriaDTO, LoginDTO LoginDTO)
        {
            try
            {
                var result = await _PackingDAL.GetSelectListPacking(FirstNumber, MaxResult, CriteriaDTO, LoginDTO);
                return result;
            }
            catch (Exception ex)
            {
                throw new Exception($"Error in PackingBLL.GetSelectListPacking: {ex.Message}", ex);
            }
        }

        public async Task<string> GetPackingProductionSummary(int FirstNumber, int MaxResult, CriteriaDTO CriteriaDTO, LoginDTO LoginDTO)
        {
            try
            {
                return await _PackingDAL.GetPackingProductionSummary(FirstNumber, MaxResult, CriteriaDTO, LoginDTO);
            }
            catch (Exception ex)
            {
                throw new Exception($"Error in PackingBLL.GetPackingProductionSummary: {ex.Message}", ex);
            }
        }

        // ── Save ──────────────────────────────────────────────────────────────

        public async Task<string> SavePacking(PackingSaveDTO dto, LoginDTO login, CancellationToken ct)
        {
            try
            {
                if (dto.OUId <= 0) throw new ArgumentException("OUId is required.");
                if (dto.ItemId <= 0) throw new ArgumentException("ItemId is required.");

                bool isNew = dto.PackingId == 0;
                int detailCount = dto.Details.Count;
                // Single AutoNumber call for header + contents, mirroring ProductionBLL.SaveProduction.
                int totalCount = (isNew ? 1 : 0) + detailCount;

                var num = await _autoNumber.GetNumberAsync(totalCount, AUTONUMBERCONSTANT.PACKING, login)
                    .ConfigureAwait(false);
                int nextId = num.StartNumber;

                if (isNew)
                    dto.PackingId = nextId++;

                dto.ModifiedById = login.UserId;
                dto.ModifiedOn = DateTime.UtcNow;
                if (isNew)
                {
                    dto.CreatedById = login.UserId;
                    dto.CreatedOn = DateTime.UtcNow;
                }

                short slNo = 1;
                foreach (var detail in dto.Details)
                {
                    detail.PackDetailId = nextId++;
                    detail.ObjectHeaderTypeId = EntityConstant.OBJECTPACKING;
                    detail.ObjectHeaderId = dto.PackingId;
                    detail.SlNo = slNo++;
                }

                var tx = await _qe.BeginTransactionAsync(login);
                try
                {
                    if (isNew)
                        await _PackingDAL.InsertPackingHeader(dto, login, tx, ct).ConfigureAwait(false);
                    else
                    {
                        await _PackingDAL.DeletePackDetailsByHeader(
                            EntityConstant.OBJECTPACKING, dto.PackingId, login, tx, ct).ConfigureAwait(false);
                        await _PackingDAL.UpdatePackingHeader(dto, login, tx, ct).ConfigureAwait(false);
                    }

                    foreach (var detail in dto.Details)
                        await _PackingDAL.SavePackDetail(detail, login, tx, ct).ConfigureAwait(false);

                    await _qe.CommitAsync(tx);
                }
                catch
                {
                    await _qe.RollbackAsync(tx);
                    throw;
                }

                return isNew
                    ? $"{SuccessResponse.SaveSuccessMessage} {dto.PackingId}"
                    : SuccessResponse.UpdateSuccessMessage;
            }
            catch (Exception ex)
            {
                throw new Exception($"Error in PackingBLL.SavePacking: {ex.Message}", ex);
            }
        }

        // ── Get ───────────────────────────────────────────────────────────────

        public async Task<string> GetPacking(int packingId, LoginDTO login, CancellationToken ct)
        {
            try
            {
                var header = await _PackingDAL.GetPacking(packingId, login, ct).ConfigureAwait(false);
                if (header is null) return JsonConvert.SerializeObject(null);

                header.Details = (await _PackingDAL
                    .GetPackDetails(EntityConstant.OBJECTPACKING, packingId, login, ct)
                    .ConfigureAwait(false)).ToList();

                return JsonConvert.SerializeObject(header);
            }
            catch (Exception ex)
            {
                throw new Exception($"Error in PackingBLL.GetPacking: {ex.Message}", ex);
            }
        }

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

        public async Task<string> DeletePacking(int packingId, LoginDTO login, CancellationToken ct)
        {
            try
            {
                var tx = await _qe.BeginTransactionAsync(login);
                try
                {
                    await _PackingDAL.DeletePackDetailsByHeader(
                        EntityConstant.OBJECTPACKING, packingId, login, tx, ct).ConfigureAwait(false);
                    await _PackingDAL.DeletePackingHeader(packingId, login, tx, ct).ConfigureAwait(false);
                    await _qe.CommitAsync(tx);
                }
                catch
                {
                    await _qe.RollbackAsync(tx);
                    throw;
                }

                return SuccessResponse.DeleteSuccessMessage;
            }
            catch (Exception ex)
            {
                throw new Exception($"Error in PackingBLL.DeletePacking: {ex.Message}", ex);
            }
        }
    }
}