using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Threading.Tasks;
using _0_Framework.Application;
using Company.Domain.CheckoutAgg;
using Company.Domain.CheckoutAgg.ValueObjects;
using Company.Domain.LeftWorkAgg;
using Company.Domain.YearlySalaryAgg;
using Company.Domain.empolyerAgg;
using Company.Domain.RollCallAgg;
using CompanyManagment.App.Contracts.Checkout;
using CompanyManagment.App.Contracts.PersonalContractingParty;
using CompanyManagment.App.Contracts.Leave;
using CompanyManagment.App.Contracts.MandantoryHours;
using _0_Framework.Domain.CustomizeCheckoutShared.ValueObjects;
using Company.Domain.EmployeeAgg;
using CompanyManagment.App.Contracts.HolidayItem;
using CompanyManagment.App.Contracts.RollCall;
using CompanyManagment.EFCore.Migrations;
using CompanyManagment.EFCore.Repository;
using System.Globalization;
using Company.Domain.LeaveAgg;
using Company.Domain.WorkshopAgg;

namespace CompanyManagment.Application;

public class CheckoutApplication : ICheckoutApplication
{
	private readonly ICheckoutRepository _checkoutRepository;
	private readonly IYearlySalaryRepository _yearlySalaryRepository;
	private readonly ILeftWorkRepository _leftWorkRepository;
	private readonly IEmployerRepository _employerRepository;
	private readonly IPersonalContractingPartyApp _contractingPartyApp;
	private readonly ILeaveApplication _leaveApplication;
	private readonly IMandatoryHoursApplication _mandatoryHoursApplication;
	private readonly IRollCallMandatoryRepository _rollCallMandatoryRepository;
	private readonly IRollCallRepository _rollCallRepository;
	private readonly IHolidayItemApplication _holidayItemApplication;


	public CheckoutApplication(ICheckoutRepository checkoutRepository, IYearlySalaryRepository yearlySalaryRepository,
		ILeftWorkRepository leftWorkRepository,
		IEmployerRepository employerRepository, IPersonalContractingPartyApp contractingPartyApp, ILeaveApplication leaveApplication, IMandatoryHoursApplication mandatoryHoursApplication, IRollCallMandatoryRepository rollCallMandatoryRepository, IRollCallRepository rollCallRepository, IHolidayItemApplication holidayItemApplication)
	{
		_checkoutRepository = checkoutRepository;
		_yearlySalaryRepository = yearlySalaryRepository;
		_leftWorkRepository = leftWorkRepository;
		_employerRepository = employerRepository;
		_contractingPartyApp = contractingPartyApp;
		_leaveApplication = leaveApplication;
		_mandatoryHoursApplication = mandatoryHoursApplication;
		_rollCallMandatoryRepository = rollCallMandatoryRepository;
		_rollCallRepository = rollCallRepository;
		_holidayItemApplication = holidayItemApplication;
	}

	[SuppressMessage("ReSharper.DPA", "DPA0007: Large number of DB records", MessageId = "count: 241")]
	public void Create(CreateCheckout command)
	{
		var operation = new OperationResult();
		var syear = Convert.ToInt32(command.ContractStart.Substring(0, 4));
		var smonth = Convert.ToInt32(command.ContractStart.Substring(5, 2));
		string month = string.Empty;
		switch (smonth)
		{
			case 1:
				month = "فروردین";
				break;
			case 2:
				month = "اردیبهشت";
				break;
			case 3:
				month = "خرداد";
				break;
			case 4:
				month = "تیر";
				break;
			case 5:
				month = "مرداد";
				break;
			case 6:
				month = "شهریور";
				break;
			case 7:
				month = "مهر";
				break;
			case 8:
				month = "آبان";
				break;
			case 9:
				month = "آذر";
				break;
			case 10:
				month = "دی";
				break;
			case 11:
				month = "بهمن";
				break;
			case 12:
				month = "اسفند";
				break;
		}
		var year = syear.ToString();

		#region SickLeav

		//var serachModel = new LeaveSearchModel()
		//{
		//	EmployeeId = command.EmployeeId,
		//	WorkshopId = command.WorkshopId,
		//	LeaveType = "استعلاجی",
		//	StartLeave = command.ContractStart,
		//	EndLeave = command.ContractEnd,
		//	IsAccepted = true,
		//};
		//var leavList = _leaveApplication.search(serachModel);
		//      int sickLeaveCount = 0;
		//if (leavList.Count > 0)
		//{

		//	foreach (var leave in leavList)
		//	{
		//		if (leave.StartLeaveGr < command.ContractStartGr && leave.EndLeaveGr <= command.ContractEndGr)
		//		{
		//                  int res = (int)((leave.EndLeaveGr - command.ContractStartGr).TotalDays +1);
		//                  sickLeaveCount += res;
		//		}
		//		else if (leave.StartLeaveGr >= command.ContractStartGr && leave.EndLeaveGr > command.ContractEndGr)
		//		{
		//			int res = (int)((command.ContractEndGr - leave.StartLeaveGr).TotalDays + 1);
		//			sickLeaveCount += res;
		//		}
		//		else
		//		{
		//			int res = (int)((leave.EndLeaveGr - leave.StartLeaveGr).TotalDays + 1);
		//			sickLeaveCount += res;
		//		}

		//	}
		//}

		#endregion

		var dayliWage = command.DayliWage.MoneyToDouble();
		// کمک هزینه اقلام
		var consumableItem = command.ConsumableItems.MoneyToDouble();
		//حق اولاد
		var familyAllowance = command.FamilyAllowance.MoneyToDouble();
		//کمک هزینه مسکن
		var housingAllowance = command.HousingAllowance.MoneyToDouble();
		//حق تاهل
		var marriedAllowance = command.MarriedAllowance.MoneyToDouble();
        //var MontlyYearsBunos =
        //_yearlySalaryRepository.GetMontlyBunosYears(command.WeeklyTime, command.ContractStartGr, command.ContractEndGr, dayliWage, command.WorkingWeeklyTime, command.officialholiday, command.friday, command.TotalHolidaysAndNotH, command.TotalHolidaysAndNotM, command.Basic, command.FridayStarttoEnd, command.DailFeeComplete, command.HasRollCall, command.HolidayWorking, command.ShiftWork);
        //دستمزد ماهانه

        #region Salary

        var totalDays = (command.ContractEndGr - command.ContractStartGr).TotalDays + 1;

        var mandatoryDays = totalDays - command.FridayStarttoEnd - command.officialholiday;

        if (!command.HasRollCall && command.ShiftWork != "4")
            mandatoryDays = totalDays - command.FridayStarttoEnd;
        var monthlyWage = command.DailySalaryAffected * totalDays;

        //پایه سنوات
        var bacicYears = command.BaseYearAffected * totalDays;
        #endregion

        //سنوات
        var years = command.YearsPay;
		//عیدی و پاداش
		var bunos = command.BonusesPay;

        //فاطمه احمدژاد === موقت عیدی و پاداش  و سنوات حساب نشه
        if (command.EmployeeId == 45104 && command.WorkshopId == 315)
        {
            years = 0;

            bunos = 0;
        }

        var sumOfWorkingDays = $"{totalDays}";
		if (command.friday > 0)
		{
			var fridayPercent = dayliWage * 40 / 100;
			//فوق العاده جمعه کاری
			command.FridayPay = fridayPercent * command.friday;
		}
        //حق بیمه سهم کارگر
        #region InsuranceDeduction

        double insuranceDeduction = 0;
        bool hasInsuranceShareTheSameAsList = false;
        if (command.InsuranceDeduction == 0)
        {
            var insuranceOverTime = command.HasInsuranceChekoutOverTime ? command.OvertimePay : 0; 
            insuranceDeduction = (monthlyWage + bacicYears + consumableItem + housingAllowance + marriedAllowance + insuranceOverTime) * 7 / 100;
        }
        else
        {
            insuranceDeduction = command.InsuranceDeduction;
            hasInsuranceShareTheSameAsList = true;
        }


        #endregion


        if (command.OvertimePay > 0 && command.AbsenceDeduction > 0)
		{
			if (command.AbsenceDeduction >= command.OvertimePay)
			{
				command.AbsenceDeduction = command.AbsenceDeduction - command.OvertimePay;
				command.OvertimePay = 0;
                command.OverTimeWorkValue = "00:00";
            }
			else
			{
				command.OvertimePay = command.OvertimePay - command.AbsenceDeduction;
				command.AbsenceDeduction = 0;
			}

		}
		var checkoutStart = $"{command.Year}/{command.Month}/01";
		var checkoutEnd = checkoutStart.FindeEndOfMonth();
		var salaryAids =
			_rollCallMandatoryRepository.SalaryAidsForCheckout(command.EmployeeId, command.WorkshopId, checkoutStart.ToGeorgianDateTime(), checkoutEnd.ToGeorgianDateTime())
				.Select(x => new CheckoutSalaryAid(x.Amount, x.SalaryAidDateTimeGe, x.SalaryAidDateTimeFa, x.CalculationDateTimeGe, x.CalculationDateTimeFa, x.Id)).ToList();

		command.SalaryAidDeduction = salaryAids.Sum(x => x.Amount.MoneyToDouble());
		
		var loanInstallments = _rollCallMandatoryRepository.LoanInstallmentForCheckout(command.EmployeeId,
				command.WorkshopId, command.ContractStartGr, command.HasLeft ? DateTime.MaxValue : command.ContractEndGr)
			.Select(x => 
				new CheckoutLoanInstallment(x.Amount, x.Month, x.Year, x.IsActive, x.RemainingAmount, x.LoanAmount, x.Id)).ToList();

		command.InstallmentDeduction = loanInstallments.Sum(x => x.AmountForMonth.MoneyToDouble());

        var rewards = new List<CheckoutReward>();
        double rewardPay = 0;
        if (command.RewardPayCompute)
        {
            rewards = _rollCallMandatoryRepository.RewardForCheckout(command.EmployeeId, command.WorkshopId, checkoutEnd.ToGeorgianDateTime(), checkoutStart.ToGeorgianDateTime())
                .Select(x => new CheckoutReward(x.Amount, x.AmountDouble, x.GrantDateFa, x.GrantDateGr, x.Description, x.Title, x.Id)).ToList();

            rewardPay = rewards.Sum(x => x.AmountDouble);
        }
		

		

		var firstDayOfMonth = $"{command.ContractStart.Substring(0, 8)}01".ToGeorgianDateTime();
		var firstDayOfCurrentMonth = new DateTime(syear, smonth, 1, new PersianCalendar());

		LeaveSearchModel sickLeaveSearch = new LeaveSearchModel()
		{
			EmployeeId = command.EmployeeId,
			WorkshopId = command.WorkshopId,
			StartLeaveGr = command.ContractStartGr,
			EndLeaveGr = command.ContractEndGr,
			IsAccepted = true,
		};
		var leaves = _leaveApplication.search(sickLeaveSearch);

		firstDayOfMonth.AddMonthsFa(1, out var lastDayOfCurrentMonth);

		lastDayOfCurrentMonth = lastDayOfCurrentMonth.AddDays(-1);

		int dateRange = (int)(lastDayOfCurrentMonth - firstDayOfCurrentMonth).TotalDays + 1;

		var holidays = _holidayItemApplication.Search(new HolidayItemSearchModel()
		{
			HolidayYear = command.ContractStartGr.ToFarsiYear()
		});
		//all the dates from start to end, to be compared with present days to get absent dates
		var completeDaysList = Enumerable.Range(0, dateRange).Select(offset => firstDayOfCurrentMonth.AddDays(offset).Date).ToList();

		var absentRecords = completeDaysList
				.ExceptBy(command.GroupedRollCalls.Select(x => x.CreationDate.Date), y => y.Date)
			.Select(x =>
			{
				var leave = leaves.FirstOrDefault(y =>
					y.EmployeeId == command.EmployeeId && y.EndLeaveGr.Date >= x.Date && y.StartLeaveGr.Date <= x.Date);
				var isHoliday = holidays.Any(y => y.HolidaydateGr == x.Date);
				var isFriday = x.Date.DayOfWeek == DayOfWeek.Friday;
				var isNormalWorkingDay = isHoliday == false && isFriday == false;
				return new CheckoutDailyRollCallViewModel()
				{
					StartDate1 = null,
					EndDate1 = null,
					DateTimeGr = x.Date,
					DayOfWeek = x.Date.DayOfWeek.ToString(),
					RollCallDateFa = x.Date.ToFarsi(),
					LeaveType = leave != null ? leave.LeaveType : "",
					IsAbsent = leave == null && isNormalWorkingDay
				};
			});

		var presentDays = command.GroupedRollCalls.Select(x =>
		{

			var orderedRollcalls = x.ShiftList.OrderBy(y => y.Start);

			var rollCallTimeSpanPerDay = x.SumOneDaySpan;
			TimeSpan breakTimePerDay = x.BreakTime;

			return new CheckoutDailyRollCallViewModel()
			{
				StartDate1 = orderedRollcalls.FirstOrDefault().Start.ToString("HH:mm"),
				EndDate1 = orderedRollcalls.FirstOrDefault().EndWithOutResTime.ToString("HH:mm"),

				StartDate2 = orderedRollcalls.Skip(1).FirstOrDefault()?.Start.ToString("HH:mm") ?? "",
				EndDate2 = orderedRollcalls.Skip(1).FirstOrDefault()?.EndWithOutResTime.ToString("HH:mm") ?? "",

				TotalhourseSpan = rollCallTimeSpanPerDay,

				BreakTimeTimeSpan = breakTimePerDay,

				DayOfWeek = x.CreationDate.DayOfWeek.DayOfWeeKToPersian(),
				RollCallDateFa = x.CreationDate.Date.ToFarsi(),
				DateTimeGr = x.CreationDate.Date,
				IsSliced = x.ShiftList.Count() > 2,
				IsAbsent = false
			};
		});


		presentDays = presentDays.Select(x => new CheckoutDailyRollCallViewModel
		{
			StartDate1 = x.StartDate1,
			EndDate1 = x.EndDate1,
			EndDate2 = x.EndDate2,
			StartDate2 = x.StartDate2,
			TotalWorkingHours = $"{(int)(x.TotalhourseSpan.TotalHours)}:{x.TotalhourseSpan.Minutes:00}",
			BreakTimeString = $"{(int)(x.BreakTimeTimeSpan.TotalHours)}:{x.BreakTimeTimeSpan.Minutes:00}",
			TotalhourseSpan = x.TotalhourseSpan,
			BreakTimeTimeSpan = x.BreakTimeTimeSpan,
			DayOfWeek = x.DayOfWeek,
			RollCallDateFa = x.RollCallDateFa,
			DateTimeGr = x.DateTimeGr,
			IsSliced = x.IsSliced,
			IsAbsent = false
		});

		var result = presentDays.Concat(absentRecords).OrderBy(x => x.DateTimeGr).ToList();
		result.ForEach(x =>
		{
			x.IsHoliday = holidays.Any(y => x.DateTimeGr.Date == y.HolidaydateGr.Date);
			x.IsFriday = x.DateTimeGr.DayOfWeek == DayOfWeek.Friday;
		});

		var checkoutRollCallDays = result.Select(x => new CheckoutRollCallDay(x.DateTimeGr, 
				x.StartDate1, x.EndDate1, x.StartDate2, x.EndDate2,
				x.BreakTimeTimeSpan, x.IsSliced, x.TotalhourseSpan, x.IsAbsent, x.IsFriday, x.IsHoliday, x.LeaveType))
			.ToList();


		double mandatoryHours = _mandatoryHoursApplication.GetMandatoryHoursByYearAndMonth(syear, smonth);
		int mandatoryWholeHours = (int)mandatoryHours;
		int mandatoryMinutes = (int)((mandatoryHours - mandatoryWholeHours) * 60);

		var totalMandatoryHours = TimeSpan.FromHours(mandatoryWholeHours).Add(TimeSpan.FromMinutes(mandatoryMinutes));
		var checkoutRollCall = new CheckoutRollCall(totalMandatoryHours, command.TotalPresentTimeSpan, command.TotalBreakTimeSpan,
			command.TotalWorkingTimeSpan, command.TotalPaidLeave, command.TotalSickLeave, checkoutRollCallDays);




		var totalClaimsDouble = monthlyWage + bacicYears + consumableItem + housingAllowance + marriedAllowance + command.OvertimePay +
								command.NightworkPay + familyAllowance + bunos + years + command.LeavePay + command.FridayPay + command.ShiftPay + rewardPay;
		var totalClaims = totalClaimsDouble.ToMoney();
		var totalDeductionDouble = insuranceDeduction + command.AbsenceDeduction + command.InstallmentDeduction + command.SalaryAidDeduction;
		var totalDeductions = totalDeductionDouble.ToMoney();
		var totalPayment = totalClaimsDouble - totalDeductionDouble;

		if (_checkoutRepository.Exists(x =>
				x.Month == command.Month && x.Year == command.Year && x.ContractNo == command.ContractNo))
		{
			operation.Failed("امکان ثبت رکورد تکراری وجود ندارد");
		}
		else
		{
			if (string.IsNullOrWhiteSpace(command.Signature))
			{
				command.Signature = "0";
			}
			

			var checkout = new Checkout(command.EmployeeFullName, command.FathersName, command.NationalCode
				, command.DateOfBirth, command.EmployeeId, command.WorkshopName, command.WorkshopId, command.ContractNo, command.ContractStartGr, command.ContractEndGr, month, year,
				command.ContractId, command.WorkingHoursId, monthlyWage, bacicYears, consumableItem, housingAllowance
				, command.OvertimePay, command.NightworkPay, command.FridayPay, 0, command.ShiftPay, familyAllowance, bunos, years, command.LeavePay, insuranceDeduction, 0, command.InstallmentDeduction, command.SalaryAidDeduction, command.AbsenceDeduction, sumOfWorkingDays,
				command.ArchiveCode, command.PersonnelCode, totalClaims, totalDeductions, totalPayment, command.Signature, marriedAllowance, command.LeaveCheckout, command.CreditLeaves, command.AbsencePeriod, command.AverageHoursPerDay, command.HasRollCall, command.OverTimeWorkValue, command.OverNightWorkValue
				, command.FridayWorkValue, command.RotatingShiftValue, command.AbsenceValue, command.TotalDayOfLeaveCompute, command.TotalDayOfYearsCompute, command.TotalDayOfBunosesCompute,
				loanInstallments, salaryAids,checkoutRollCall,command.EmployeeMandatoryHours, hasInsuranceShareTheSameAsList, rewards, rewardPay);

			_checkoutRepository.CreateCkeckout(checkout).GetAwaiter().GetResult();
			//_checkoutRepository.SaveChanges();

			//var employeeFullName = new SqlParameter("@EmployeeFullName", SqlDbType.NVarChar, 50);
			//employeeFullName.Value = command.EmployeeFullName;
			//var fathersName = new SqlParameter("@FathersName", SqlDbType.NVarChar, 20);
			//fathersName.Value = command.EmployeeFullName;

		}


	}

	public OperationResult Edit(EditCheckout command)
	{
		throw new NotImplementedException();
	}

	public EditCheckout GetDetails(long id)
	{
		return _checkoutRepository.GetDetails(id);
	}

	public async Task<CreateCheckoutListViewModel> GetContractResultToCreateCheckout(long workshopId, long employeeId, string year, string month,
		string contractStart, string contractEnd)
	{
		return await _checkoutRepository.GetContractResultToCreateCheckout(workshopId, employeeId, year, month, contractStart,
			contractEnd);

	}

    public Task<List<CheckoutViewModel>> SearchCheckoutOptimized(CheckoutSearchModel searchModel)
    {
        return _checkoutRepository.SearchCheckoutOptimized(searchModel);
    }

    public async Task<List<CheckoutViewModel>> Search(CheckoutSearchModel searchModel)
    {
        var watch = System.Diagnostics.Stopwatch.StartNew();
        watch.Start();
        var result = new List<CheckoutViewModel>();
		var query = await _checkoutRepository.SearchForMainCheckout(searchModel);
		query = query.Select(x => new CheckoutViewModel()
		{
			Id = x.Id,
			EmployeeFullName = x.EmployeeFullName,
			ContractStart = x.ContractStart,
			ContractEnd = x.ContractEnd,
			ContractStartGr = x.ContractStartGr,
			ContractEndGr = x.ContractEndGr,
			PersonnelCode = x.PersonnelCode,
			PersonnelCodeInt = x.PersonnelCodeInt,
			ArchiveCode = x.ArchiveCode,
			SumOfWorkingDays = x.SumOfWorkingDays,
			WorkshopName = x.WorkshopName,
			Month = x.Month,
			Year = x.Year,
			ContractNo = x.ContractNo,
			ContractId = x.ContractId,
			WorkshopId = x.WorkshopId,
			EmployeeId = x.EmployeeId,
			IsActiveString = x.IsActiveString,
			Signature = x.Signature,
			CreationDate = x.CreationDate,
			EmployerName = _employerRepository.GetEmployerByWorkshopId(x.WorkshopId).FirstOrDefault()?.EmployerFullName,
			IsBlockCantracingParty = _employerRepository.GetEmployerByWorkshopId(x.WorkshopId).FirstOrDefault()?.IsBlockContractingParty,
		}).ToList();
        //foreach (var items in query)
        //{
        //    var s = _employerRepository.GetEmployerByWorkshopId(items.WorkshopId);
        //    if (s != null)
        //    {
        //        items.EmployerName = s.FirstOrDefault().EmployerFullName;
        //    }
        //    result.Add(items);
        //    //var employeId = _context.WorkshopEmployers?.Where(x => x.WorkshopId == items.WorkshopId)
        //    //        .Select(x => x.EmployerId).FirstOrDefault();
        //    //var employerName = _context.Employers?.FirstOrDefault(x => x.id == employeId).FullName;
        //    // = employerName;

        //}
        Console.WriteLine("old : " + watch.Elapsed);
        return query;

	}

	public List<CheckoutViewModel> SimpleSearch(CheckoutSearchModel searchModel)
	{
		return _checkoutRepository.SimpleSearch(searchModel);
	}

	public List<CheckoutViewModel> PrintAll(List<long> id)
	{
		var result = _checkoutRepository.PrintAll(id);
		var oneRecord = result.FirstOrDefault();
		if (oneRecord == null)
			return new();
		result.ForEach(x =>
		{


			int yearFa;
			int monthFa;
			try
			{
				yearFa = int.Parse(oneRecord.Year);
				monthFa = oneRecord.Month.ToMonthByStringValue();
			}
			catch (Exception e)
			{
				return;
			}
			double mandatoryHours = _mandatoryHoursApplication.GetMandatoryHoursByYearAndMonth(yearFa, monthFa);
			int mandatoryWholeHours = (int)mandatoryHours;
			int mandatoryMinutes = (int)((mandatoryHours - mandatoryWholeHours) * 60);
			var totalWorking = new TimeSpan(x.MonthlyRollCall.Sum(y => y.TotalhourseSpan.Ticks));
			var totalBreakTime = new TimeSpan(x.MonthlyRollCall.Sum(y => y.BreakTimeTimeSpan.Ticks));
			TimeSpan totalPresent = totalWorking + totalBreakTime;
			if (x.CheckoutRollCall == null)
			{
				if (x.HasRollCall)
				{
					totalWorking = new TimeSpan(x.MonthlyRollCall.Sum(x => x.TotalhourseSpan.Ticks)) -
					               x.TotalHourlyLeave;
					totalBreakTime = new TimeSpan(x.MonthlyRollCall.Sum(x => x.BreakTimeTimeSpan.Ticks));
					totalPresent = totalWorking + totalBreakTime;
				}
				else
				{
					totalBreakTime = new TimeSpan(x.MonthlyRollCall.Sum(x => x.BreakTimeTimeSpan.Ticks));
					totalPresent = new TimeSpan(x.MonthlyRollCall.Sum(x => x.TotalhourseSpan.Ticks));
					totalWorking = totalPresent - totalBreakTime;
				}

				x.TotalWorkingTimeStr =
					Tools.ToFarsiHoursAndMinutes((int)totalWorking.TotalHours, totalWorking.Minutes, "-");
				x.TotalBreakTimeStr =
					Tools.ToFarsiHoursAndMinutes((int)totalBreakTime.TotalHours, totalBreakTime.Minutes, "-");
				x.TotalPresentTimeStr =
					Tools.ToFarsiHoursAndMinutes((int)totalPresent.TotalHours, totalPresent.Minutes, "-");
				x.TotalMandatoryTimeStr = Tools.ToFarsiHoursAndMinutes(mandatoryWholeHours, mandatoryMinutes, "-");
				
			}
		});
			
		return result;
	}

	public CheckoutViewModel PrintOne(long id)
	{
		var result = _checkoutRepository.PrintOne(id);

		int yearFa;
		int monthFa;
		try
		{
			yearFa = int.Parse(result.Year);
			monthFa = result.Month.ToMonthByStringValue();
		}
		catch (Exception e)
		{
			return new();
		}
		double mandatoryHours = _mandatoryHoursApplication.GetMandatoryHoursByYearAndMonth(yearFa, monthFa);
		int mandatoryWholeHours = (int)mandatoryHours;
		int mandatoryMinutes = (int)((mandatoryHours - mandatoryWholeHours) * 60);
		TimeSpan totalWorking;
		TimeSpan totalBreakTime;
		TimeSpan totalPresent;
		TimeSpan totalHoursLeave;
		if (result.HasRollCall)
		{
			totalWorking = new TimeSpan(result.MonthlyRollCall.Sum(x => x.TotalhourseSpan.Ticks)) - result.TotalHourlyLeave;
			totalBreakTime = new TimeSpan(result.MonthlyRollCall.Sum(x => x.BreakTimeTimeSpan.Ticks));
			totalPresent = totalWorking + totalBreakTime;
		}
		else
		{
			totalBreakTime = new TimeSpan(result.MonthlyRollCall.Sum(x => x.BreakTimeTimeSpan.Ticks));
			totalPresent = new TimeSpan(result.MonthlyRollCall.Sum(x => x.TotalhourseSpan.Ticks));
			totalWorking = totalPresent - totalBreakTime;
		}

		result.TotalWorkingTimeStr = Tools.ToFarsiHoursAndMinutes((int)totalWorking.TotalHours, totalWorking.Minutes, "-");
		result.TotalBreakTimeStr = Tools.ToFarsiHoursAndMinutes((int)totalBreakTime.TotalHours, totalBreakTime.Minutes, "-");
		result.TotalPresentTimeStr = Tools.ToFarsiHoursAndMinutes((int)totalPresent.TotalHours, totalPresent.Minutes, "-");
		result.TotalMandatoryTimeStr = Tools.ToFarsiHoursAndMinutes(mandatoryWholeHours, mandatoryMinutes, "-");

		return result;
	}

	public CheckoutLeavePrintViewModel LeavePrint(long id)
	{
		return _checkoutRepository.PrintLeave(id);
	}

	public OperationResult Sign(long id)
	{
		var opration = new OperationResult();
		var contract = _checkoutRepository.Get(id);
		if (contract == null)
			return opration.Failed("رکورد مورد نظر یافت نشد");

		contract.Sign();


		_checkoutRepository.SaveChanges();
		opration.IsSuccedded = true;
		return opration.Succcedded();
	}

	public OperationResult UnSign(long id)
	{
		var opration = new OperationResult();
		var contract = _checkoutRepository.Get(id);
		if (contract == null)
			return opration.Failed("رکورد مورد نظر یافت نشد");

		contract.UnSign();


		_checkoutRepository.SaveChanges();
		opration.IsSuccedded = true;
		return opration.Succcedded();
	}

	public OperationResult Active(long id)
	{
		var opration = new OperationResult();
		var contract = _checkoutRepository.Get(id);
		if (contract == null)
			return opration.Failed("رکورد مورد نظر یافت نشد");

		contract.Active();

		_checkoutRepository.SaveChanges();
		return opration.Succcedded();
	}

	public OperationResult DeActive(long id)
	{
		var opration = new OperationResult();
		var contract = _checkoutRepository.Get(id);
		if (contract == null)
			return opration.Failed("رکورد مورد نظر یافت نشد");

		contract.DeActive();


		_checkoutRepository.SaveChanges();

		return opration.Succcedded();
	}

	public OperationResult RemoveCheckout(long id)
	{
		return _checkoutRepository.RemoveCheckout(id);
	}

	public OperationResult CustomSet(long id, double rewardPay, double salaryAidDeduction)
	{
		var opration = new OperationResult();
		var checkout = _checkoutRepository.Get(id);
		var totalClaimsDouble = checkout.TotalClaims.MoneyToDouble();
		var totalDeductionsDouble = checkout.TotalDeductions.MoneyToDouble();
		totalClaimsDouble = (double)(totalClaimsDouble - checkout.RewardPay);
		totalDeductionsDouble = totalDeductionsDouble - checkout.SalaryAidDeduction;

		var totalClaims = totalClaimsDouble + rewardPay;
		var totalDeductions = totalDeductionsDouble + salaryAidDeduction;



		var totalClaimsString = totalClaims.ToMoney();
		var totalDeductionsString = totalDeductions.ToMoney();
		var totalPayment = totalClaims - totalDeductions;

		checkout.CustomSet(rewardPay, salaryAidDeduction, totalClaimsString, totalDeductionsString, totalPayment);

		_checkoutRepository.SaveChanges();
		opration.IsSuccedded = true;
		return opration.Succcedded();
	}

	#region Client

	public List<CheckoutViewModel> SearchForClient(CheckoutSearchModel searchModel)
	{
		return _checkoutRepository.SearchForClient(searchModel);
	}

	#endregion
	#region NewChangeByHeydari
	public List<long> CheckHasSignature(List<long> ids)
	{
		return _checkoutRepository.CheckHasSignature(ids);
	}
	public OperationResult DeleteAllCheckouts(List<long> ids)
	{
		return _checkoutRepository.DeleteAllCheckouts(ids);
	}
	public OperationResult DeleteCheckout(long id)
	{
		return _checkoutRepository.DeleteCheckout(id);
	}
	public async Task<List<CheckoutViewModel>> SearchForMainCheckout(CheckoutSearchModel searchModel)
	{
		return await _checkoutRepository.SearchForMainCheckout(searchModel);
	}
	#endregion
	#region Pooya


	public List<(long EmployeeId, DateTime CheckoutStart, DateTime CheckoutEnd)> GetLastCheckoutsByWorkshopIdForWorkFlow(long workshopId, DateTime start, DateTime end)
	{
		return _checkoutRepository.GetLastCheckoutsByWorkshopIdForWorkFlow(workshopId, start, end);
	}

	#endregion
}