using GB5Shared.DTO.Framework.Criteria;
using GB5Shared.DTO.Framework.Logging;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.EntityHandler;
using GB5Shared.EventLogPublish;
using GB5Shared.GenerateAutoNumber;
using GB5Shared.QueryExecutor;
using GB5Shared.Resource.Response;
using PayRollDAL.CustomeCode.Advance;
using PayRollDAL.DTO.Advance;
using PayRollDAL.DTO.TLeave;
using System;
using System.Collections.Generic;
using System.Data.Common;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static GB5Shared.GB5Constant.Constant;

namespace PayRollBLL.Advance
{
    public class AdvanceBLL : IAdvanceBLL
    {
        private readonly IAdvanceDAL _AdvanceDAL;
        private readonly AutoNumber _AutoNumber;
        private readonly IQueryExecutor _QueryExecutor;
        private readonly BaseEntityAppService<AdvanceDTO> _baseEntityAppService;
        private readonly VoucherNumberService _VoucherNumberService;


        public AdvanceBLL(IAdvanceDAL IAdvanceDAL, AutoNumber autoNumber, IQueryExecutor IQueryExecutor, BaseEntityAppService<AdvanceDTO> baseEntityAppService, VoucherNumberService voucherNumberService)
        {
            _AdvanceDAL = IAdvanceDAL;
            _AutoNumber = autoNumber;
            _QueryExecutor = IQueryExecutor;
            _baseEntityAppService = baseEntityAppService;
            _VoucherNumberService = voucherNumberService;
        }
        public async Task<string> GetAdvance(int AdvanceId, LoginDTO LoginDTO)
        {
            try
            {
                return await _AdvanceDAL.GetAdvance(AdvanceId, LoginDTO);
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<string> GetSelectListAdvance(int FirstNumber, int MaxResult, CriteriaDTO CriteriaDTO, LoginDTO LoginDTO)
        {
            try
            {
                return await _AdvanceDAL.GetSelectListAdvance(FirstNumber, MaxResult, CriteriaDTO, LoginDTO);
            }
            catch (Exception ex)
            {
                throw new Exception("Error in GetSelectListAdvance", ex);
            }
        }

        public async Task<string> GetSelectListAdvanceEmployee(CriteriaDTO CriteriaDTO, LoginDTO LoginDTO)
        {
            try
            {
                return await _AdvanceDAL.GetSelectListAdvanceEmployee(CriteriaDTO, LoginDTO);
            }
            catch (Exception ex)
            {
                throw new Exception("Error in GetSelectListAdvanceEmployee", ex);
            }
        }

        public async Task<string> GetAdvanceReport(int FirstNumber, int MaxResult, CriteriaDTO CriteriaDTO, LoginDTO LoginDTO)
        {
            try
            {
                return await _AdvanceDAL.GetAdvanceReport(FirstNumber, MaxResult, CriteriaDTO, LoginDTO);
            }
            catch (Exception ex)
            {
                throw new Exception("Error in GetAdvanceReport", ex);
            }
        }





        public async Task<string> SaveAdvance(AdvanceDTO AdvanceDTO, LoginDTO LoginDTO)
        {
            try
            {

                if (AdvanceDTO == null)
                    throw new ArgumentNullException(nameof(AdvanceDTO));

                bool isNew = AdvanceDTO.AdvanceId == 0;

                // Pre-Transaction : Auto Number
                var AdvanceAutoNumber = await _AutoNumber.GetAutoNumber(
                    1,
                    AUTONUMBERCONSTANT.ADVANCE,
                    LoginDTO);


                var Trans = await _QueryExecutor.BeginTransactionAsync(LoginDTO);

                try
                {
                    await _baseEntityAppService.ExecuteSaveAsync(
                        EntityConstant.ADVANCE,
                        EventTypeConstant.SAVEADVANCEEVENTTYPEID,
                        AdvanceDTO,
                        LoginDTO,
                        async tx =>
                        {
                            if (isNew)
                            {
                                AdvanceDTO.AdvanceId = AdvanceAutoNumber.StartNumber;
                                AdvanceDTO.AdvanceCreatedById = LoginDTO.UserId;
                                AdvanceDTO.AdvanceCreatedOn = DateTime.UtcNow;

                                string? GeneratedNumber = await _VoucherNumberService.GetNextVoucherNumberAsync(
                                    AdvanceDTO.BizTransactionTypeId,
                                    AdvanceDTO.AdvanceAdvanceDate,
                                    LoginDTO,
                                    tx);

                                if (GeneratedNumber != null)
                                    AdvanceDTO.AdvanceAdvanceNumber = GeneratedNumber;
                            }

                            AdvanceDTO.AdvanceModifiedById = LoginDTO.UserId;
                            AdvanceDTO.AdvanceModifiedOn = DateTime.UtcNow;

                            int Result;

                            if (isNew)
                            {
                                Result = await _AdvanceDAL.SaveAdvance(AdvanceDTO, LoginDTO, tx);
                            }
                            else
                            {
                                Result = await _AdvanceDAL.UpdateAdvance(AdvanceDTO, LoginDTO, tx);
                            }

                            return Result;
                        },
                        null,
                        BIZTRANSACTIONCLASSCONSTANT.ADVANCEREQUEST,
                        BizTransactionConstant.ADVANCE,
                        Trans,
                        isNew);

                    await _QueryExecutor.CommitAsync(Trans);

                    if (isNew)
                    {
                        return SuccessResponse.SaveSuccessMessage + AdvanceDTO.AdvanceAdvanceNumber;
                    }
                    else
                    {
                        return SuccessResponse.UpdateSuccessMessage + AdvanceDTO.AdvanceAdvanceNumber;
                    }
                }
                catch (Exception)
                {
                    await _QueryExecutor.RollbackAsync(Trans);
                    throw;
                }
            }
            catch (Exception) 
            {
                throw;
            }
        }
        public async Task<string> DeleteAdvance(int AdvanceId, LoginDTO LoginDTO)
        { 
            try
            { 
                return await _AdvanceDAL.DeleteAdvance(AdvanceId, LoginDTO);
            }
            catch (Exception)
            {
               
                throw;
            }
        }

     
    }
}