using GB5Shared.DTO.Framework.AutoNumber;
using GB5Shared.DTO.Framework.Criteria;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.GenerateAutoNumber;
using GB5Shared.Resource.Response;
using GB5Shared.Validation;
using PayRollDAL.CustomeCode.MonthlyAttendance;
using PayRollDAL.DTO.MonthlyAttendance;
using System;
using System.ComponentModel.DataAnnotations;
using System.Threading.Tasks;

namespace PayRollBLL.MonthlyAttendance
{
    // Classic master-detail CRUD BLL for MonthlyAttendance (TMONTHLYATTENDANCE +
    // TMONTHLYATTENDANCEADDON). Out of scope: Crew-Timesheet Prepare/Submit/Approve/Status
    // workflow, BPM/Activiti integration, wage-rule/posting-position joined "standard data load"
    // reports, formula-based PaidDays/BillDays/OTDays recalculation.
    public class MonthlyAttendanceBLL : IMonthlyAttendanceBLL
    {
        private readonly IMonthlyAttendanceDAL _monthlyAttendanceDAL;
        private readonly AutoNumber _autoNumber;
        private readonly IValidation _validation;

        public MonthlyAttendanceBLL(
            IMonthlyAttendanceDAL monthlyAttendanceDAL,
            AutoNumber autoNumber,
            IValidation validation)
        {
            _monthlyAttendanceDAL = monthlyAttendanceDAL;
            _autoNumber = autoNumber;
            _validation = validation;
        }

        public async Task<string> GetMonthlyAttendance(int monthlyAttendanceId, LoginDTO loginDTO)
        {
            try
            {
                return await _monthlyAttendanceDAL.GetMonthlyAttendance(monthlyAttendanceId, loginDTO);
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<string> SaveMonthlyAttendance(MonthlyAttendanceDTO monthlyAttendanceDTO, LoginDTO loginDTO)
        {
            if (monthlyAttendanceDTO == null)
            {
                throw new ArgumentNullException(nameof(monthlyAttendanceDTO));
            }

            AutoNumberDTO? autoNumberDTO = null;

            try
            {
                await _validation.Range(1, int.MaxValue, monthlyAttendanceDTO.EmployeeId, nameof(monthlyAttendanceDTO.EmployeeId));
                await _validation.Range(1, int.MaxValue, monthlyAttendanceDTO.PayPeriodId, nameof(monthlyAttendanceDTO.PayPeriodId));

                monthlyAttendanceDTO.MonthlyAttendanceModifiedById = loginDTO.UserId;
                monthlyAttendanceDTO.MonthlyAttendanceModifiedOn = DateTime.UtcNow;

                int count = 1;

                if (monthlyAttendanceDTO.MonthlyAttendanceId == 0)
                {
                    autoNumberDTO = await _autoNumber.GetAutoNumber(count, "MonthlyAttendance", loginDTO);

                    monthlyAttendanceDTO.MonthlyAttendanceId = autoNumberDTO.StartNumber;
                    monthlyAttendanceDTO.MonthlyAttendanceCreatedById = loginDTO.UserId;
                    monthlyAttendanceDTO.MonthlyAttendanceCreatedOn = DateTime.UtcNow;

                    await _monthlyAttendanceDAL.SaveMonthlyAttendance(monthlyAttendanceDTO, loginDTO);

                    return $"{SuccessResponse.SaveSuccessMessage} {monthlyAttendanceDTO.MonthlyAttendanceId}";
                }
                else
                {
                    await _monthlyAttendanceDAL.UpdateMonthlyAttendance(monthlyAttendanceDTO, loginDTO);

                    return $"{SuccessResponse.UpdateSuccessMessage} {monthlyAttendanceDTO.MonthlyAttendanceId}";
                }
            }
            catch (ValidationException vex)
            {
                throw new Exception(vex.Message);
            }
            catch (Exception)
            {
                if (autoNumberDTO != null && monthlyAttendanceDTO.MonthlyAttendanceId > 0)
                {
                    await _autoNumber.RollbackAutoNumber("MonthlyAttendance", monthlyAttendanceDTO.MonthlyAttendanceId, loginDTO);
                }

                throw;
            }
        }

        public async Task<int> DeleteMonthlyAttendance(int monthlyAttendanceId, LoginDTO loginDTO)
        {
            try
            {
                return await _monthlyAttendanceDAL.DeleteMonthlyAttendance(monthlyAttendanceId, loginDTO);
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<string> GetSelectListMonthlyAttendance(
            int firstNumber,
            int maxResult,
            CriteriaDTO criteriaDTO,
            LoginDTO loginDTO,
            bool isCount = false)
        {
            try
            {
                if (firstNumber == 0 && maxResult == 0)
                {
                    firstNumber = 0;
                    maxResult = 10;
                }

                return await _monthlyAttendanceDAL.GetSelectListMonthlyAttendance(firstNumber, maxResult, criteriaDTO, loginDTO, isCount);
            }
            catch (Exception ex)
            {
                throw new Exception($"Error in GetSelectListMonthlyAttendance BLL: {ex.Message}", ex);
            }
        }

        public async Task<string> GetMonthlyAttendanceListAsync(
            int firstNumber,
            int maxResult,
            CriteriaDTO criteriaDTO,
            LoginDTO loginDTO,
            bool isCount = false)
        {
            try
            {
                (int validatedFirstNumber, int validatedMaxResult) = ValidatePagination(firstNumber, maxResult);

                return await _monthlyAttendanceDAL.GetMonthlyAttendanceListAsync(
                    validatedFirstNumber,
                    validatedMaxResult,
                    criteriaDTO,
                    loginDTO,
                    isCount
                );
            }
            catch (Exception ex)
            {
                throw new Exception($"Error in GetMonthlyAttendanceListAsync BLL: {ex.Message}", ex);
            }
        }

        private (int FirstNumber, int MaxResult) ValidatePagination(int firstNumber, int maxResult)
        {
            if (firstNumber == -1 && maxResult == -1)
            {
                return (firstNumber, maxResult);
            }

            int validatedFirstNumber = firstNumber < -1 ? -1 : firstNumber;
            int validatedMaxResult = maxResult < -1 ? -1 : maxResult;

            const int MAX_RECORDS = 1000;
            if (validatedMaxResult > MAX_RECORDS)
            {
                validatedMaxResult = MAX_RECORDS;
            }

            return (validatedFirstNumber, validatedMaxResult);
        }
    }
}