using AdminDAL.CustomCode.Period;
using AdminDAL.DTO.Period;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.EntityHandler;
using GB5Shared.GenerateAutoNumber;
using GB5Shared.QueryExecutor;
using GB5Shared.Resource.Response;
using Newtonsoft.Json;
using PayRollDAL.CustomeCode.Perq;
using PayRollDAL.DTO.Perq;
using System;
using System.Linq;
using System.Threading.Tasks;
using static GB5Shared.GB5Constant.Constant;

namespace PayRollBLL.Perquisites
{
    public class PerquisitesBLL : IPerquisitesBLL
    {
        private readonly IPerqDAL _PerqDAL;
        private readonly IPeriodDAL _PeriodDAL;
        private readonly AutoNumber _AutoNumber;
        private readonly IQueryExecutor _QueryExecutor;
        private readonly BaseEntityAppService<PerqDTO> _baseEntityAppService;

        public PerquisitesBLL(IPerqDAL IPerqDAL, IPeriodDAL IPeriodDAL, AutoNumber autoNumber, IQueryExecutor IQueryExecutor, BaseEntityAppService<PerqDTO> baseEntityAppService)
        {
            _PerqDAL = IPerqDAL;
            _PeriodDAL = IPeriodDAL;
            _AutoNumber = autoNumber;
            _QueryExecutor = IQueryExecutor;
            _baseEntityAppService = baseEntityAppService;
        }

        public async Task<string> GetPerquisites(int PerqId, LoginDTO LoginDTO)
        {
            try
            {
                return await _PerqDAL.GetPerq(PerqId, LoginDTO);
            }
            catch (Exception)
            {
                throw;
            }
        }

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

        public async Task<string> SavePerquisites(PerqDTO PerqDTO, LoginDTO LoginDTO)
        {
            try
            {
                if (PerqDTO == null)
                    throw new ArgumentNullException(nameof(PerqDTO));

                bool isNew = PerqDTO.PerqId == 0;

                // Validate PerqDate falls within the selected Period's date range —
                // mirrors GB4 PerquisitesBLL.SavePerq's ValidationFaliedException(UNIB0083) check.
                string PeriodJson = await _PeriodDAL.GetPeriod(PerqDTO.PeriodId, LoginDTO);
                PeriodDTO Period = JsonConvert.DeserializeObject<PeriodDTO>(PeriodJson);
                if (Period == null || PerqDTO.PerqPerqDate < Period.PeriodFromDate || PerqDTO.PerqPerqDate > Period.PeriodToDate)
                {
                    throw new ArgumentException("Perquisite date must fall within the selected period's date range.");
                }

                // count = 1 (header) + number of new (PerqDetailId == 0) detail rows
                int NewDetailCount = PerqDTO.PerqDetailArray.Count(d => d.PerqDetailId == 0);
                int Count = 1 + NewDetailCount;

                // Pre-Transaction : Auto Number
                var PerqAutoNumber = await _AutoNumber.GetAutoNumber(
                    Count,
                    AUTONUMBERCONSTANT.PERQ,
                    LoginDTO);

                var Trans = await _QueryExecutor.BeginTransactionAsync(LoginDTO);

                try
                {
                    await _baseEntityAppService.ExecuteSaveAsync(
                        EntityConstant.PERQ,
                        EventTypeConstant.PRSPERQSAVE,
                        PerqDTO,
                        LoginDTO,
                        async tx =>
                        {
                            int AttributeCount = 0;

                            if (isNew)
                            {
                                PerqDTO.PerqId = PerqAutoNumber.StartNumber;
                                AttributeCount = 1;
                                PerqDTO.PerqCreatedById = LoginDTO.UserId;
                                PerqDTO.PerqCreatedOn = DateTime.UtcNow;
                            }

                            PerqDTO.PerqModifiedById = LoginDTO.UserId;
                            PerqDTO.PerqModifiedOn = DateTime.UtcNow;

                            int Result;

                            if (isNew)
                            {
                                Result = await _PerqDAL.SavePerq(PerqDTO, LoginDTO, tx);

                                for (int d = 0; d < PerqDTO.PerqDetailArray.Count; d++)
                                {
                                    PerqDTO.PerqDetailArray[d].PerqDetailSlNo = (short)(d + 1);
                                    if (PerqDTO.PerqDetailArray[d].PerqDetailId == 0)
                                    {
                                        PerqDTO.PerqDetailArray[d].PerqDetailId = PerqAutoNumber.StartNumber + AttributeCount;
                                        AttributeCount += 1;
                                    }

                                    await _PerqDAL.SavePerqDetail(PerqDTO.PerqDetailArray[d], PerqDTO.PerqId, LoginDTO, tx);
                                }
                            }
                            else
                            {
                                await _PerqDAL.DeletePerqDetailByPerqId(PerqDTO.PerqId, LoginDTO, tx);
                                Result = await _PerqDAL.UpdatePerq(PerqDTO, LoginDTO, tx);

                                for (int d = 0; d < PerqDTO.PerqDetailArray.Count; d++)
                                {
                                    PerqDTO.PerqDetailArray[d].PerqDetailSlNo = (short)(d + 1);
                                    if (PerqDTO.PerqDetailArray[d].PerqDetailId == 0)
                                    {
                                        PerqDTO.PerqDetailArray[d].PerqDetailId = PerqAutoNumber.StartNumber + AttributeCount;
                                        AttributeCount += 1;
                                    }

                                    await _PerqDAL.SavePerqDetail(PerqDTO.PerqDetailArray[d], PerqDTO.PerqId, LoginDTO, tx);
                                }
                            }

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

                    await _QueryExecutor.CommitAsync(Trans);

                    if (isNew)
                    {
                        return SuccessResponse.SaveSuccessMessage + PerqDTO.PerqNumber;
                    }
                    else
                    {
                        return SuccessResponse.UpdateSuccessMessage + PerqDTO.PerqNumber;
                    }
                }
                catch (Exception)
                {
                    await _QueryExecutor.RollbackAsync(Trans);
                    throw;
                }
            }
            catch (Exception)
            {
                throw;
            }
        }
    }
}