using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Threading.Tasks;
using _0_Framework.Application;
using _0_Framework.Application.Enums;
using _0_Framework.Exceptions;
using _0_Framework.InfraStructure;
using Company.Domain.ContractAgg;
using Company.Domain.empolyerAgg;
using Company.Domain.LeftWorkAgg;
using Company.Domain.YearlySalaryAgg;
using CompanyManagment.App.Contracts.Contract;
using CompanyManagment.App.Contracts.Employee;
using CompanyManagment.App.Contracts.Employer;
using CompanyManagment.App.Contracts.LeftWork;
using CompanyManagment.App.Contracts.Workshop;
using Microsoft.EntityFrameworkCore;
using PersianTools.Core;
using DateTime = System.DateTime;

namespace CompanyManagment.EFCore.Repository;

public class ContractRepository : RepositoryBase<long, Contract>, IContractRepository
{
    private readonly CompanyContext _context;
    private readonly IEmployeeApplication _employeeApplication;
    private readonly IEmployerApplication _employerApplication;
    private readonly IWorkshopApplication _workshopApplication;
    private readonly IEmployerRepository _employerRepository;
    private readonly IYearlySalaryRepository _yearlySalaryRepository;
    private readonly ILeftWorkRepository _leftWorkRepository;
    private readonly IAuthHelper _authHelper;
    public ContractRepository(CompanyContext context, IEmployeeApplication employeeApplication, IEmployerApplication employerApplication, IWorkshopApplication workshopApplication, IEmployerRepository employerRepository, IAuthHelper authHelper, IYearlySalaryRepository yearlySalaryRepository, ILeftWorkRepository leftWorkRepository) : base(context)
    {
        _context = context;
        _employeeApplication = employeeApplication;
        _employerApplication = employerApplication;
        _workshopApplication = workshopApplication;
        _employerRepository = employerRepository;
        _authHelper = authHelper;
        _yearlySalaryRepository = yearlySalaryRepository;
        _leftWorkRepository = leftWorkRepository;
    }


    public async Task<double> GetManualDailWage(long workshopId, long employeeId, long yearlySalaryId, DateTime contractStart)
    {

        var lastContract = await _context.Contracts
            .Where(x => x.WorkshopIds == workshopId && x.EmployeeId == employeeId && x.IsActiveString == "true" && x.ContarctStart < contractStart)
            .OrderByDescending(x => x.ContarctStart)
            .FirstOrDefaultAsync();
        //اگر قردادی  قبل از  قرارداد جدید نداشت
        if (lastContract == null)
            return 0;
        //اگر آخرین قرداد مزد دلخواه نداشت
        if (!lastContract.HasManualDailyWage)
            return 0;

        var lastContractYearlySalary = await _context.YearlySalaries
            .FirstOrDefaultAsync(x => x.StartDate <= lastContract.ContarctStart && x.EndDate >= lastContract.ContarctStart);

        //اگر دستمزد آخرین قراداد و قرداد جدید از یک مقادیر سالانه بودن بدون ارتقاء دستمزد دلخواه آخرین قرداد ارسال میشه
        if (lastContractYearlySalary.id == yearlySalaryId)
            return lastContract.DailySalaryUnAffected;


        var dailyWageResult = _yearlySalaryRepository.UpgradeManualDailyWage(contractStart,
            lastContractYearlySalary.StartDate, lastContract.DailySalaryUnAffected).GetAwaiter().GetResult();

        return dailyWageResult.DailyWage;
    }

    public async Task<UpgradeManualDailyWageModel> GetManualDailWageList(long workshopId, long employeeId,
        DateTime contractStart)
    {
        var oldContracts = await _context.Contracts
            .Where(x => x.WorkshopIds == workshopId && x.EmployeeId == employeeId && x.IsActiveString == "true" && x.DailyWageType == "ManualDailyWage" && x.ContarctStart < contractStart)
            .OrderByDescending(x => x.ContarctStart)
            .FirstOrDefaultAsync();
        if (oldContracts == null)
            return new UpgradeManualDailyWageModel();

        //var endOfMonthFromStart = ($"{contractStart.ToFarsi().FindeEndOfMonth()}").ToGeorgianDateTime();


        var result =await _yearlySalaryRepository.UpgradeManualDailyWage(contractStart, oldContracts.ContarctStart,
            oldContracts.DailySalaryUnAffected);

        return result;
    }



    public EditContract GetDetails(long id)
    {
        return _context.Contracts.Select(x => new EditContract
            {
                Id = x.id,
                PersonnelCode = x.PersonnelCode,
                EmployerId = x.EmployerId,
                EmployeeId = x.EmployeeId,
                WorkshopIds = x.WorkshopIds,
                YearlySalaryId = x.YearlySalaryId,
                DayliWage = x.DayliWage,
                ContarctStart = x.ContarctStart.ToFarsi(),
                ContractEnd = x.ContractEnd.ToFarsi(),
                ContractStartGr = x.ContarctStart,
                ContractEndGr = x.ContractEnd,
                GetWorkDate = x.GetWorkDate.ToFarsi(),
                SetContractDate = x.SetContractDate.ToFarsi(),
                JobType = x.JobType,
                ContractType = x.ContractType,
                WorkshopAddress1 = x.WorkshopAddress1,
                WorkshopAddress2 = x.WorkshopAddress2,
                ContractNo = x.ContractNo,
                JobTypeId = x.JobTypeId,
                ConsumableItems = x.ConsumableItems,
                HousingAllowance = x.HousingAllowance,
                WorkingHoursWeekly = x.WorkingHoursWeekly,
                FamilyAllowance = x.FamilyAllowance,
                ContractPeriod = x.ContractPeriod,
                AgreementSalary = x.AgreementSalary,
                ArchiveCode = x.ArchiveCode,
                BaseYearAffected = x.BaseYearAffected,
                BaseYearUnAffected = x.BaseYearUnAffected,
                DailySalaryAffected = x.DailySalaryAffected,
                DailySalaryUnAffected = x.DailySalaryUnAffected,
                HasManualDailyWage = x.HasManualDailyWage,
                DailyWageType = x.DailyWageType,





            })
            .FirstOrDefault(x => x.Id == id);
    }

    public EditContract GetContractByStartEnd(DateTime start, DateTime end, long workshopId, long employeeId)
    {
	    var res = _context.Contracts.FirstOrDefault(x =>
		    x.WorkshopIds == workshopId && x.EmployeeId == employeeId && x.ContarctStart <= start && x.ContractEnd >= end);
	    if (res == null)
		    return new EditContract();
	    return new EditContract()
	    {
            Id = res.id,
            GetWorkDate = res.GetWorkDate.ToFarsi(),
		};
    }
    public List<ContractViweModel> Search(ContractSearchModel searchModel)
    {
        var AcountID = _authHelper.CurrentAccountId();
        var workshopAcounts = _context.WorkshopAccounts.Where(x => x.AccountId == AcountID)
            .Select(x => x.WorkshopId).ToList();
        var emp = _context.WorkshopEmployers.Where(x => x.EmployerId == searchModel.EmployerId)
            .Select(x => x.WorkshopId).ToList();
        var employer = _context.Employers.Select(m => new EmployerViewModel
        {
            Id = m.id,
            FullName = m.FullName
        }).ToList();
        var query = _context.Contracts.Select(x => new ContractViweModel
        {
            Id = x.id,
            PersonnelCode = x.PersonnelCode,
            EmployerId = x.EmployerId,
            EmployeeId = x.EmployeeId,
            WorkshopIds = x.WorkshopIds,
            YearlySalaryId = x.YearlySalaryId,
            DayliWage = x.DayliWage,
            ContarctStart = x.ContarctStart.ToFarsi(),
            ContractEnd = x.ContractEnd.ToFarsi(),
            ContractStartGr = x.ContarctStart,
            ContractEndGr = x.ContractEnd,
            ContractNo = x.ContractNo,
            ArchiveCode = x.ArchiveCode,
            IsActiveString = x.IsActiveString,
            GetWorkDate = x.GetWorkDate.ToFarsi(),
            SetContractDate = x.SetContractDate.ToFarsi(),
            JobType = x.JobType,
            ContractType = x.ContractType,
            WorkshopAddress1 = x.WorkshopAddress1,
            WorkshopAddress2 = x.WorkshopAddress2,
            JobTypeId = x.JobTypeId,
            ConsumableItems = x.ConsumableItems,
            FamilyAllowance = x.FamilyAllowance,
            ContractPeriod = x.ContractPeriod,
            Signature = x.Signature,
            EmployerName = x.Employer.FullName,
            EmployeeName = x.Employee.FName + " " + x.Employee.LName,
            WorkshopName = x.Workshop.WorkshopName,




        });
        if (searchModel.WorkshopIds != 0)
            query = query.Where(x => x.WorkshopIds == searchModel.WorkshopIds);
        if (searchModel.EmployeeId != 0)
            query = query.Where(x => x.EmployeeId == searchModel.EmployeeId);
        if (searchModel.EmployerId != 0)
        {

            query = query.Where(x => emp.Contains(x.WorkshopIds));

        }
        if (!string.IsNullOrWhiteSpace(searchModel.ContractNo))
            query = query.Where(x => x.ContractNo == searchModel.ContractNo);

        if (!string.IsNullOrWhiteSpace(searchModel.ContractPeriod))
            query = query.Where(x => x.ContractPeriod == searchModel.ContractPeriod);


        if (!string.IsNullOrWhiteSpace(searchModel.ContarctStart) &&
            !string.IsNullOrWhiteSpace(searchModel.ContractEnd))
        {
            var start = searchModel.ContarctStart.ToGeorgianDateTime();
            var endd = searchModel.ContractEnd.ToGeorgianDateTime();
            query = query.Where(x =>
                x.ContractStartGr >= start && x.ContractEndGr <= endd);
        }
        else if (!string.IsNullOrWhiteSpace(searchModel.Year) && !string.IsNullOrWhiteSpace(searchModel.Month))
        {
            var y = searchModel.Year + "/" + searchModel.Month + "/01";
            string y2 = string.Empty;
            int month = Convert.ToInt32(searchModel.Month);
            int year = Convert.ToInt32(searchModel.Year);

            if (month <= 6)
            {
                y2 = $"{searchModel.Year}/{searchModel.Month}/31";
            }
            else if (month > 6 && month < 12)
            {
                y2 = $"{searchModel.Year}/{searchModel.Month}/30";
            }
            else if (month == 12)
            {
                switch (year)
                {
                    case 1346:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1350:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1354:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1358:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1362:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1366:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1370:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1375:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1379:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1383:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1387:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1391:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1395:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1399:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1403:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1408:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1412:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1416:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1420:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1424:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1428:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1432:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1436:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1441:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1445:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;

                    default:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/29";
                        break;

                }
            }

            var start = y.ToGeorgianDateTime();
            var end = y2.ToGeorgianDateTime();

            query = query.Where(x => x.ContractStartGr >= start && x.ContractStartGr < end && x.ContractEndGr > start && x.ContractEndGr <= end ||
                                     x.ContractStartGr <= start && x.ContractEndGr >= end || start <= x.ContractStartGr && end > x.ContractStartGr || end >= x.ContractEndGr && start < x.ContractEndGr);
        }

        if (searchModel.IsActiveString == null)
        {
            query = query.Where(x => x.IsActiveString == "true");
        }

        if (searchModel.IsActiveString == "false")
        {
            query = query.Where(x => x.IsActiveString == "false");
        }
        else if (searchModel.IsActiveString == "both")
        {
            query = query.Where(x => x.IsActiveString == "false" || x.IsActiveString == "true");
        }
        query = query.Where(e => workshopAcounts.Contains(e.WorkshopIds));

        if (searchModel.EditPersonnelCode)
        {
            return query.OrderByDescending(x => x.Id).ToList();

        }
        else if (searchModel.EmployeeId != 0 || !string.IsNullOrWhiteSpace(searchModel.Year) && searchModel.WorkshopIds != 0)
        {
            if (!string.IsNullOrWhiteSpace(searchModel.Year) && string.IsNullOrWhiteSpace(searchModel.Month))
            {
                var startOfYear = searchModel.Year + "/01/01";
                var startOfyearGr = startOfYear.ToGeorgianDateTime();
                var endOfYear = $"{searchModel.Year}/12/01".FindeEndOfMonth();
                var endOfYearGr = endOfYear.ToGeorgianDateTime();


                query = query.Where(x => x.ContractStartGr >= startOfyearGr && x.ContractEndGr <= endOfYearGr);
            }
            return query.OrderByDescending(x => x.Id).ToList();
        }
        else 
        {
            return query.OrderByDescending(x => x.Id).Take(100).ToList();
        }

    }

    public List<ContractViweModel> SearchForextension(ContractSearchModel searchModel)
    {
        //var Allemplyee = _employeeApplication.GetEmployee();
        //var Allemployer = _employerApplication.GetEmployers();
        var workshop = _workshopApplication.GetDetails(searchModel.WorkshopIds);
          

        
        var today = DateTime.Now;
        var faToday = string.Empty;
        var GrogorianThisMonthStart = new DateTime();


        int syear = 0;
        int smonth = 0;
        var leftWoekSerchResult = _context.LeftWorkList.Select(x => new LeftWorkViewModel()
        {
            Id = x.id,
            LeftWorkDate = x.LeftWorkDate.ToFarsi(),
            StartWorkDate = x.StartWorkDate.ToFarsi(),
            LeftWorkDateGr = x.LeftWorkDate,
            StartWorkDateGr = x.StartWorkDate,
            EmployeeFullName = x.EmployeeFullName,
            WorkshopName = x.WorkshopName,
            WorkshopId = x.WorkshopId,
            EmployeeId = x.EmployeeId

        }).Where(x=>x.WorkshopId == searchModel.WorkshopIds).ToList();
            

        if (string.IsNullOrWhiteSpace(searchModel.ContarctStart) && string.IsNullOrWhiteSpace(searchModel.ContractEnd))
        {
            if (searchModel.Month == "0" && searchModel.Year == "0")
            {
                faToday = today.ToFarsi();
            }
            else
            {

                faToday = $"{searchModel.Year}/{searchModel.Month}/01";
            }

            syear = Convert.ToInt32(faToday.Substring(0, 4));
            smonth = Convert.ToInt32(faToday.Substring(5, 2));


            var PersianStartMonth = new PersianDateTime(syear, smonth, 01);
            PersianStartMonth = PersianStartMonth.AddMonths(1);
            GrogorianThisMonthStart = PersianStartMonth.ToGregorianDateTime();
        }







        var query = _context.Contracts.Select(x => new ContractViweModel
        {

            Id = x.id,
            PersonnelCode = x.PersonnelCode,
            EmployerId = x.EmployerId,
            EmployeeId = x.EmployeeId,
            WorkshopIds = x.WorkshopIds,
            YearlySalaryId = x.YearlySalaryId,
            DayliWage = x.DayliWage,
            ContarctStart = x.ContarctStart.ToFarsi(),
            ContractEnd = x.ContractEnd.ToFarsi(),
            ContractStartGr = x.ContarctStart,
            ContractEndGr = x.ContractEnd,
            ContractNo = x.ContractNo,
            ArchiveCode = x.ArchiveCode,
            IsActiveString = x.IsActiveString,
            GetWorkDate = x.GetWorkDate.ToFarsi(),
            SetContractDate = x.SetContractDate.ToFarsi(),
            JobType = x.JobType,
            ContractType = x.ContractType,
            WorkshopAddress1 = x.WorkshopAddress1,
            WorkshopAddress2 = x.WorkshopAddress2,
            JobTypeId = x.JobTypeId,
            ConsumableItems = x.ConsumableItems,
            FamilyAllowance = x.FamilyAllowance,
            ContractPeriod = x.ContractPeriod,
            Signature = x.Signature,





        }).Where(x=>x.WorkshopIds == searchModel.WorkshopIds).ToList();

        if (searchModel.WorkshopIds != 0)
        {
            var step1 = query.Where(x =>
                    x.WorkshopIds == searchModel.WorkshopIds && x.IsActiveString == "true")
                .GroupBy(x => x.EmployeeId).Select(x => x.Key).ToList();
            var contractData = new List<long>();
            foreach (var i in step1)
            {
                if (string.IsNullOrWhiteSpace(searchModel.ContarctStart) && string.IsNullOrWhiteSpace(searchModel.ContractEnd))
                {
                    var step2 = query.Where(x => x.EmployeeId == i && x.IsActiveString == "true")
                        .Where(x => x.ContractStartGr < GrogorianThisMonthStart).OrderByDescending(x => x.ContarctStart).ToList();
                    var step3 = step2.Select(x => x.Id).FirstOrDefault();

                    contractData.Add(step3);
                }
                else
                {
                    var start = searchModel.ContarctStart.ToGeorgianDateTime();
                    var endd = searchModel.ContractEnd.ToGeorgianDateTime();
                    var step2 = query.Where(x => x.EmployeeId == i && x.IsActiveString == "true")
                        .Where(x => x.ContractStartGr < endd).OrderByDescending(x => x.ContarctStart).ToList();
                    var step3 = step2.Select(x => x.Id).FirstOrDefault();

                    contractData.Add(step3);
                }


            }
            query = query.Where(e => contractData.Contains(e.Id))
                .Where(x => x.WorkshopIds == searchModel.WorkshopIds).ToList();



        }

        if (searchModel.EmployeeId != 0)
            query = query.Where(x => x.EmployeeId == searchModel.EmployeeId).ToList();
        var Join = new List<ContractViweModel>();
        var employer = query.FirstOrDefault();
        var employerFullName = _employerApplication.GetDetails(employer.EmployerId).FullName;
        //IQueryable<ContractViweModel> newQuery = null;
        foreach (var item in query)
        {
              
               
            var EmployeeFullName = leftWoekSerchResult.FirstOrDefault(x=>x.EmployeeId == item.EmployeeId)?.EmployeeFullName;
     
           
               
            var a = new ContractViweModel
            {
                Id = item.Id,
                PersonnelCode = item.PersonnelCode,
                EmployerId = item.EmployerId,
                EmployeeId = item.EmployeeId,
                WorkshopIds = item.WorkshopIds,
                YearlySalaryId = item.YearlySalaryId,
                DayliWage = item.DayliWage,
                ContarctStart = item.ContarctStart,
                ContractEnd = item.ContractEnd,
                ContractStartGr = item.ContractStartGr,
                ContractEndGr = item.ContractEndGr,
                ContractNo = item.ContractNo,
                ArchiveCode = item.ArchiveCode,
                IsActiveString = item.IsActiveString,
                GetWorkDate = item.GetWorkDate,
                SetContractDate = item.SetContractDate,
                JobType = item.JobType,
                ContractType = item.ContractType,
                WorkshopAddress1 = item.WorkshopAddress1,
                WorkshopAddress2 = item.WorkshopAddress2,
                JobTypeId = item.JobTypeId,
                ConsumableItems = item.ConsumableItems,
                FamilyAllowance = item.FamilyAllowance,
                ContractPeriod = item.ContractPeriod,
                Signature = item.Signature,
                EmployeeName = EmployeeFullName,
                EmployerName = employerFullName,
                WorkshopName = workshop.WorkshopFullName,

            };
            
                
            if (leftWoekSerchResult.Count > 0)
            {
                var left = leftWoekSerchResult.Where(x => x.EmployeeId == item.EmployeeId).ToList();
                var leftWorkLast = left.OrderByDescending(x => x.StartWorkDateGr).FirstOrDefault();
                var start = new DateTime();
                if (string.IsNullOrWhiteSpace(searchModel.ContarctStart) && string.IsNullOrWhiteSpace(searchModel.ContractEnd))
                {
                    start = GrogorianThisMonthStart;
                }
                else
                {
                    start = searchModel.ContarctStart.ToGeorgianDateTime();
                }

                var check = left.FirstOrDefault(x => x.StartWorkDateGr <= start &&
                                                     x.LeftWorkDateGr > start);
                if (check != null)
                {
                    if (check.LeftWorkDate == "1500/01/01")
                    {
                        Join.Add(a);
                    }
                    else
                    {
                        if (check.LeftWorkDateGr > a.ContractEndGr)
                        {
                            Join.Add(a);
                        }

                    }
                }
                    



            }
                

        }

        //query = Join.AsQueryable();

        return Join.OrderByDescending(x => x.Id).ToList();
    }

    public List<ContractViweModel> SearchForCheckout(ContractSearchModel searchModel)
    {
        var Allemplyee = _employeeApplication.GetEmployee();
        var Allemployer = _employerApplication.GetEmployers();
        var Allworkshop = _workshopApplication.GetWorkshop();
        var today = DateTime.Now;
        var faToday = string.Empty;
         









        var query = _context.Contracts.Select(x => new ContractViweModel
        {

            Id = x.id,
            PersonnelCode = x.PersonnelCode,
            EmployerId = x.EmployerId,
            EmployeeId = x.EmployeeId,
            WorkshopIds = x.WorkshopIds,
            YearlySalaryId = x.YearlySalaryId,
            DayliWage = x.DayliWage,
            ContarctStart = x.ContarctStart.ToFarsi(),
            ContractEnd = x.ContractEnd.ToFarsi(),
            ContractStartGr = x.ContarctStart,
            ContractEndGr = x.ContractEnd,
            ContractNo = x.ContractNo,
            ArchiveCode = x.ArchiveCode,
            IsActiveString = x.IsActiveString,
            GetWorkDate = x.GetWorkDate.ToFarsi(),
            SetContractDate = x.SetContractDate.ToFarsi(),
            JobType = x.JobType,
            ContractType = x.ContractType,
            WorkshopAddress1 = x.WorkshopAddress1,
            WorkshopAddress2 = x.WorkshopAddress2,
            JobTypeId = x.JobTypeId,
            ConsumableItems = x.ConsumableItems,
            FamilyAllowance = x.FamilyAllowance,
            ContractPeriod = x.ContractPeriod,
            Signature = x.Signature,





        });

        if (searchModel.WorkshopIds != 0)
        {
            //var step1 = _context.Contracts.Where(x =>
            //        x.WorkshopIds == searchModel.WorkshopIds && x.IsActiveString == "true")
            //    .GroupBy(x => x.EmployeeId).Select(x => x.Key).ToList();
            //var contractData = new List<long>();
            //foreach (var i in step1)
            //{

            //    var start = searchModel.ContarctStart.ToGeorgianDateTime();
            //    var endd = searchModel.ContractEnd.ToGeorgianDateTime();
            //    var step2 = _context.Contracts.Where(x => x.EmployeeId == i && x.IsActiveString == "true")
            //        .Where(x => x.ContarctStart >= start && x.ContractEnd <= endd).OrderByDescending(x => x.ContarctStart);
            //    var step3 = step2.Select(x => x.id).FirstOrDefault();

            //    contractData.Add(step3);



            //}
            //query = query.Where(e => contractData.Contains(e.Id))
            //    .Where(x => x.WorkshopIds == searchModel.WorkshopIds);

            var start = searchModel.ContarctStart.ToGeorgianDateTime();
            var endd = searchModel.ContractEnd.ToGeorgianDateTime();
            query = query.Where(x => x.WorkshopIds == searchModel.WorkshopIds && x.IsActiveString == "true")
                .Where(x => x.ContractStartGr <= start && x.ContractEndGr >= endd || start <= x.ContractStartGr && endd > x.ContractStartGr || endd >= x.ContractEndGr && start < x.ContractEndGr);

        }

        if (searchModel.EmployeeId != 0)
            query = query.Where(x => x.EmployeeId == searchModel.EmployeeId);
        var Join = new List<ContractViweModel>();
        //IQueryable<ContractViweModel> newQuery = null;
        foreach (var item in query)
        {
            var employeeFullName = string.Empty;
            var employerFullName = string.Empty;
            var workshopName = string.Empty;
            var employeeF = Allemplyee.FirstOrDefault(x => x.Id == item.EmployeeId);
            if (employeeF != null)
                employeeFullName = employeeF.EmployeeFullName;
            var employerF = Allemployer.FirstOrDefault(x => x.Id == item.EmployerId);
            if (employerF != null)
                employerFullName = employerF.FullName;
            var workshopN = Allworkshop.FirstOrDefault(x => x.Id == item.WorkshopIds);
            if (workshopN != null)
                workshopName = workshopN.WorkshopFullName;

            var a = new ContractViweModel
            {
                Id = item.Id,
                PersonnelCode = item.PersonnelCode,
                EmployerId = item.EmployerId,
                EmployeeId = item.EmployeeId,
                WorkshopIds = item.WorkshopIds,
                YearlySalaryId = item.YearlySalaryId,
                DayliWage = item.DayliWage,
                ContarctStart = item.ContarctStart,
                ContractEnd = item.ContractEnd,
                ContractStartGr = item.ContractStartGr,
                ContractEndGr = item.ContractEndGr,
                ContractNo = item.ContractNo,
                ArchiveCode = item.ArchiveCode,
                IsActiveString = item.IsActiveString,
                GetWorkDate = item.GetWorkDate,
                SetContractDate = item.SetContractDate,
                JobType = item.JobType,
                ContractType = item.ContractType,
                WorkshopAddress1 = item.WorkshopAddress1,
                WorkshopAddress2 = item.WorkshopAddress2,
                JobTypeId = item.JobTypeId,
                ConsumableItems = item.ConsumableItems,
                FamilyAllowance = item.FamilyAllowance,
                ContractPeriod = item.ContractPeriod,
                Signature = item.Signature,
                EmployeeName = employeeFullName,
                EmployerName = employerFullName,
                WorkshopName = workshopName,

            };
            Join.Add(a);

        }

        query = Join.AsQueryable();

        return query.OrderByDescending(x => x.Id).ToList();
    }

    public ContractSeparationViewModel contractSeparation(string year, string month, DateTime contractStart, DateTime ContractEnd, long employeeId,
        long workshopId)
    {
        bool hasLeft = false;
        var searchModel = new LeftWorkSearchModel()
        {
            EmployeeId = employeeId,
            WorkshopId = workshopId,

        };

        var leftworkList = _leftWorkRepository.search(searchModel);
        var lastLeftWork = leftworkList.FirstOrDefault(x => contractStart <= x.LeftWorkDateGr && ContractEnd >= x.StartWorkDateGr);
		if (leftworkList.Count == 0 || lastLeftWork == null)
	        return new ContractSeparationViewModel()
	        {
		        checker = false
	        };
		
        //if (lastLeftWork.StartWorkDateGr > contractStart)
        //    lastLeftWork = leftworkList.FirstOrDefault(x =>
        //        x.StartWorkDateGr <= contractStart && x.LeftWorkDateGr > contractStart);
        //if(lastLeftWork == null)
	       // lastLeftWork = leftworkList.FirstOrDefault(x =>
		      //  x.StartWorkDateGr >= contractStart && x.LeftWorkDateGr > contractStart);
		if (lastLeftWork.LeftWorkDate != "1500/01/01" && lastLeftWork.LeftWorkDateGr < ContractEnd && lastLeftWork.LeftWorkDateGr >= contractStart)
        {
            ContractEnd = lastLeftWork.LeftWorkDateGr.AddDays(-1);
            hasLeft = true;
            var start = contractStart.ToFarsi();
            var end = ContractEnd.ToFarsi();
            var ContractPreiodsList = new List<PeriodStartEnd>();
            var CheckoutMonth = int.Parse(month);

            var syear = Convert.ToInt32(start.Substring(0, 4));
            var smonth = Convert.ToInt32(start.Substring(5, 2));
            var sday = Convert.ToInt32(start.Substring(8, 2));

            var eyear = Convert.ToInt32(end.Substring(0, 4));
            var emonth = Convert.ToInt32(end.Substring(5, 2));
            var eday = Convert.ToInt32(end.Substring(8, 2));

            var PersianStartDate = new PersianDateTime(syear, smonth, sday);
            var PersianStartDateAddingMount = new PersianDateTime(syear, smonth, 1);
            var PersianEndDate = new PersianDateTime(eyear, emonth, eday);

            

            var totalmonth = ((PersianEndDate.Year - PersianStartDateAddingMount.Year) * 12) + (PersianEndDate.Month - PersianStartDateAddingMount.Month) + 1;
            for (int i = 0; i < totalmonth; i++)
            {


                var currentEndDate = PersianStartDateAddingMount.AddMonths(1).AddDays(-1);
                if (currentEndDate > PersianEndDate)
                {
                    currentEndDate = PersianEndDate;
                }

                var period = new PeriodStartEnd
                {
                    startC = PersianStartDate.ToString("yyyy/MM/dd"),
                    endC = currentEndDate.ToString("yyyy/MM/dd"),
                    monthC = currentEndDate.Month
                };
                ContractPreiodsList.Add(period);
                //Console.WriteLine($"Month {i + 1} : {PersianStartDate.ToString("yyyy-MM-dd")} to {currentEndDate.ToString("yyyy-MM-dd")}");

                PersianStartDate = PersianStartDate.AddMonths(1);
                PersianStartDate = new PersianDateTime(PersianStartDate.Year, PersianStartDate.Month, 1);


            }

            var periodSelect = ContractPreiodsList.FirstOrDefault(x => x.monthC == CheckoutMonth);
            if (periodSelect != null)
            {
                var startDate = periodSelect.startC.ToGeorgianDateTime();
                var endDate = periodSelect.endC.ToGeorgianDateTime();



                var result = new ContractSeparationViewModel()
                {
                    StartWorkDate = lastLeftWork.StartWorkDateGr,
                    LeftWorkDate = ContractEnd,
                    HasLeft = hasLeft,
                    ContarctStart = periodSelect.startC,
                    ContractEnd = periodSelect.endC,
                    ContractStartGr = startDate,
                    ContractEndGr = endDate,
                    checker = true,
                };
                return result;
            }
            else
            {
                return new ContractSeparationViewModel()
                {
                    checker = false
                };
            }
        }
        if (lastLeftWork.LeftWorkDate != "1500/01/01" && lastLeftWork.LeftWorkDateGr >= ContractEnd && lastLeftWork.LeftWorkDateGr > contractStart)
        {
            var lastWorkDay = lastLeftWork.LeftWorkDateGr.AddDays(-1);

           
                if (lastLeftWork.LeftWorkDateGr == ContractEnd)
                {
                    ContractEnd = lastWorkDay;
                    hasLeft = true;
                }

                if (lastWorkDay == ContractEnd)
                {
                    hasLeft = true;
                }
                
            
         
              

            var start = contractStart.ToFarsi();
            var end = ContractEnd.ToFarsi();
            var ContractPreiodsList = new List<PeriodStartEnd>();
            var CheckoutMonth = int.Parse(month);

            var syear = Convert.ToInt32(start.Substring(0, 4));
            var smonth = Convert.ToInt32(start.Substring(5, 2));
            var sday = Convert.ToInt32(start.Substring(8, 2));

            var eyear = Convert.ToInt32(end.Substring(0, 4));
            var emonth = Convert.ToInt32(end.Substring(5, 2));
            var eday = Convert.ToInt32(end.Substring(8, 2));

            var PersianStartDate = new PersianDateTime(syear, smonth, sday);
            var PersianStartDateAddingMount = new PersianDateTime(syear, smonth, 1);
            var PersianEndDate = new PersianDateTime(eyear, emonth, eday);



            var totalmonth = ((PersianEndDate.Year - PersianStartDateAddingMount.Year) * 12) + (PersianEndDate.Month - PersianStartDateAddingMount.Month) + 1;
            for (int i = 0; i < totalmonth; i++)
            {


                var currentEndDate = PersianStartDateAddingMount.AddMonths(1).AddDays(-1);
                if (currentEndDate > PersianEndDate)
                {
                    currentEndDate = PersianEndDate;
                }

                var period = new PeriodStartEnd
                {
                    startC = PersianStartDate.ToString("yyyy/MM/dd"),
                    endC = currentEndDate.ToString("yyyy/MM/dd"),
                    monthC = currentEndDate.Month
                };
                ContractPreiodsList.Add(period);
                //Console.WriteLine($"Month {i + 1} : {PersianStartDate.ToString("yyyy-MM-dd")} to {currentEndDate.ToString("yyyy-MM-dd")}");

                PersianStartDate = PersianStartDate.AddMonths(1);
                PersianStartDate = new PersianDateTime(PersianStartDate.Year, PersianStartDate.Month, 1);


            }

            var periodSelect = ContractPreiodsList.FirstOrDefault(x => x.monthC == CheckoutMonth);
            if (periodSelect != null)
            {
                var startDate = periodSelect.startC.ToGeorgianDateTime();
                var endDate = periodSelect.endC.ToGeorgianDateTime();



                var result = new ContractSeparationViewModel()
                {
                    StartWorkDate = lastLeftWork.StartWorkDateGr,
                    LeftWorkDate = ContractEnd,
                    HasLeft = hasLeft,
                    ContarctStart = periodSelect.startC,
                    ContractEnd = periodSelect.endC,
                    ContractStartGr = startDate,
                    ContractEndGr = endDate,
                    checker = true,
                };
                return result;
            }
            else
            {
                return new ContractSeparationViewModel()
                {
                    checker = false
                };
            }
        }
        else if (lastLeftWork.LeftWorkDate != "1500/01/01" && contractStart > lastLeftWork.LeftWorkDateGr)
        {
            return new ContractSeparationViewModel()
            {
                checker = false
            };
        }
        else if (lastLeftWork.LeftWorkDate == "1500/01/01")
        {
            var start = contractStart.ToFarsi();
            var end = ContractEnd.ToFarsi();
            var ContractPreiodsList = new List<PeriodStartEnd>();
            var CheckoutMonth = int.Parse(month);

            var syear = Convert.ToInt32(start.Substring(0, 4));
            var smonth = Convert.ToInt32(start.Substring(5, 2));
            var sday = Convert.ToInt32(start.Substring(8, 2));

            var eyear = Convert.ToInt32(end.Substring(0, 4));
            var emonth = Convert.ToInt32(end.Substring(5, 2));
            var eday = Convert.ToInt32(end.Substring(8, 2));

            var PersianStartDate = new PersianDateTime(syear, smonth, sday);
            var PersianStartDateAddingMount = new PersianDateTime(syear, smonth, 1);
            var PersianEndDate = new PersianDateTime(eyear, emonth, eday);

            //for (var startDate = PersianStartDate; startDate <= PersianEndDate; startDate = startDate.AddDays(1))
            //{

            //}

            var totalmonth = ((PersianEndDate.Year - PersianStartDateAddingMount.Year) * 12) + (PersianEndDate.Month - PersianStartDateAddingMount.Month) + 1;
            for (int i = 0; i < totalmonth; i++)
            {


                var currentEndDate = PersianStartDateAddingMount.AddMonths(1).AddDays(-1);
                if (currentEndDate > PersianEndDate)
                {
                    currentEndDate = PersianEndDate;
                }

                var period = new PeriodStartEnd
                {
                    startC = PersianStartDate.ToString("yyyy/MM/dd"),
                    endC = currentEndDate.ToString("yyyy/MM/dd"),
                    monthC = currentEndDate.Month
                };
                ContractPreiodsList.Add(period);
                //Console.WriteLine($"Month {i + 1} : {PersianStartDate.ToString("yyyy-MM-dd")} to {currentEndDate.ToString("yyyy-MM-dd")}");

                PersianStartDate = PersianStartDate.AddMonths(1);
                PersianStartDate = new PersianDateTime(PersianStartDate.Year, PersianStartDate.Month, 1);


            }

            var periodSelect = ContractPreiodsList.FirstOrDefault(x => x.monthC == CheckoutMonth);
            if (periodSelect != null)
            {
                var startDate = periodSelect.startC.ToGeorgianDateTime();
                var endDate = periodSelect.endC.ToGeorgianDateTime();



                var result = new ContractSeparationViewModel()
                {
                    StartWorkDate = lastLeftWork.StartWorkDateGr,
                    HasLeft = hasLeft,
                    ContarctStart = periodSelect.startC,
                    ContractEnd = periodSelect.endC,
                    ContractStartGr = startDate,
                    ContractEndGr = endDate,
                    checker = true,
                    LeftWorkDate = new DateTime(2121, 3, 21),
                };
                return result;
            }
            else
            {
                return new ContractSeparationViewModel()
                {
                    checker = false
                };
            }

        }
        else
        {
            return new ContractSeparationViewModel()
            {
                checker = false
            };
        }


    }

    public List<ContractViweModel> PrintAll(List<long> id)
    {
           
        var workshopEmpList = GetWorkshopEmployer();
        var query = new List<ContractViweModel>();

        foreach (var item in id)
        {
            var workshops = new List<WorkshopViewModel>();
            var employees = new List<EmployeeViewModel>();


            var c = _context.Contracts.Select(x => new ContractViweModel
                {
                    Id = x.id,
                    PersonnelCode = x.PersonnelCode,
                    EmployerId = x.EmployerId,
                    EmployeeId = x.EmployeeId,
                    PersonnelCodeInt = Convert.ToInt32(x.PersonnelCode),
                    WorkshopIds = x.WorkshopIds,
                    YearlySalaryId = x.YearlySalaryId,
                    DayliWage = x.DayliWage,
                    ContarctStart = x.ContarctStart.ToFarsi(),
                    ContractEnd = x.ContractEnd.ToFarsi(),
                    ContractStartGr = x.ContarctStart,
                    ContractEndGr = x.ContractEnd,
                    ContractNo = x.ContractNo,
                    ArchiveCode = x.ArchiveCode,
                    IsActiveString = x.IsActiveString,
                    GetWorkDate = x.GetWorkDate.ToFarsi(),
                    SetContractDate = x.SetContractDate.ToFarsi(),
                    JobType = x.JobType,
                    ContractType = x.ContractType,
                    WorkshopAddress1 = x.WorkshopAddress1,
                    WorkshopAddress2 = x.WorkshopAddress2,
                    JobTypeId = x.JobTypeId,
                    ConsumableItems = x.ConsumableItems,
                    FamilyAllowance = x.FamilyAllowance,
                    ContractPeriod = x.ContractPeriod,
                    WorkingHoursWeekly = x.WorkingHoursWeekly,
                    HousingAllowance = x.HousingAllowance





                })
                .SingleOrDefault(x => x.Id == item);

            var weeklyDouble = 0.0;
            var weekly = c.WorkingHoursWeekly;
            c.WorkingHoursWeekly = WeeklyHourConvertor(weekly);
            var emp = workshopEmpList.Where(x => x.WorkshopId == c.WorkshopIds)
                .Select(x => x.EmployerId).ToList();
            c.Employers = _employerRepository.GetEmployers(emp);
            var workshopSelect = _workshopApplication.GetDetails(c.WorkshopIds);
            var workshop = new WorkshopViewModel()
            {
                WorkshopName = workshopSelect.WorkshopName,
                InsuranceCode = workshopSelect.InsuranceCode,
                ArchiveCode = workshopSelect.ArchiveCode,
                Address = $"{workshopSelect.State} - {workshopSelect.City} - {workshopSelect.Address}",

            };
            workshops.Add(workshop);
            c.Workshops = workshops;

            var employeeSelect = _employeeApplication.GetDetails(c.EmployeeId);
            var employee = new EmployeeViewModel()
            {
                EmployeeFullName = employeeSelect.EmployeeFullName,
                NationalCode = employeeSelect.NationalCode,
                IdNumber = employeeSelect.IdNumber,
                DateOfBirth = employeeSelect.DateOfBirth,
                LevelOfEducation = employeeSelect.LevelOfEducation,
                FatherName = employeeSelect.FatherName,
                Address = $"{employeeSelect.State} - {employeeSelect.City} - {employeeSelect.Address}",


            };
            employees.Add(employee);


            c.Employees = employees;


            var LeftWorkSerchModel = new LeftWorkSearchModel()
            {
                WorkshopId = c.WorkshopIds,
                EmployeeId = c.EmployeeId
            };
            var LeftWorkList = _leftWorkRepository.search(LeftWorkSerchModel);
            if (LeftWorkList.Count > 0)
            {
                c.JobType = LeftWorkList.FirstOrDefault()?.JobName;
            }
            query.Add(c);
        }
        query = query.OrderBy(x => x.PersonnelCodeInt).ToList();
        int printNumer = 0;
        foreach (var rec in query)
        {
            printNumer += 1;
            rec.PrintCounter = printNumer;
        }
        return query;
    }

    private static string WeeklyHourConvertor(string weekly)
    {
	    double weeklyDouble;
	    if (!string.IsNullOrWhiteSpace(weekly) &&
	        weekly != "24 - 12" && weekly != "24 - 24" && weekly != "36 - 12" && weekly != "48 - 24")
	    {
		    if (weekly.Contains("/"))
		    {
			    weeklyDouble = double.Parse(weekly);
			    var minute = (int)((weeklyDouble % 1) * 60);
			    var hour = (int)(weeklyDouble);
			    return hour + " " + "ساعت و" + " " + minute + " " + "دقیقه";
		    }
		    else if (weekly.Contains("."))
		    {
			    weeklyDouble = double.Parse(weekly, CultureInfo.InvariantCulture);
			    var minute = (int)((weeklyDouble % 1) * 60);
			    var hour = (int)(weeklyDouble);
			    return hour + " " + "ساعت و" + " " + minute + " " + "دقیقه";
		    }
		    else
		    {
			    return weekly + " " + "ساعت";
		    }


	    }

	    return "";
    }

    public IQueryable<WorkshopEmployerViewModel> GetWorkshopEmployer()
    {
        return _context.WorkshopEmployers.Select(x => new WorkshopEmployerViewModel
        {
            EmployerId = x.EmployerId,
            WorkshopId = x.WorkshopId
        });
    }
    
    public long FindPersonnelCode(long workshopId, long employeeId)
    {
        long personnelCode = 0;
        var employee = _context.Contracts.Any(x => x.EmployeeId == employeeId && x.WorkshopIds == workshopId && x.IsActiveString == "true");
        var exist = _context.Contracts.Any(x => x.WorkshopIds == workshopId && x.PersonnelCode > 0 && x.IsActiveString == "true");
        if (exist && !employee)
        {
            var workshoplist = _context.Contracts.Where(x => x.WorkshopIds == workshopId).ToList();
            personnelCode = workshoplist.Max(x => x.PersonnelCode);
        }
        else
        {
            personnelCode = 0;
        }

        if (employee)
        {
            long pcode = 0;
            var p = _context.Contracts.FirstOrDefault(x => x.EmployeeId == employeeId && x.WorkshopIds == workshopId && x.IsActiveString == "true");
            if (p != null)
            {
                pcode = p.PersonnelCode;
            }

            return pcode;
        }
        else
        {
            return personnelCode += 1;
        }

    }

    public string ContractStartCheck(DateTime cstart, DateTime cend, long employeeId, long workshopId)
    {
        string duplicateMessage = "";
        var exist = _context.Contracts.FirstOrDefault(x => x.EmployeeId == employeeId && x.WorkshopIds == workshopId && ((x.ContarctStart <= cstart && x.ContractEnd >= cstart && x.IsActiveString == "true") || (x.ContarctStart <= cend && x.ContractEnd >= cend && x.IsActiveString == "true")));
        if (exist != null)
        {
            //var duplicate = _context.Contracts.FirstOrDefault(x => x.EmployeeId == employeeId && (x.ContarctStart <= cstart && x.ContractEnd >= cstart));
            duplicateMessage = $"این پرسنل یک قرار داد از تاریخ {exist.ContarctStart.ToFarsi()} تا تاریخ {exist.ContractEnd.ToFarsi()} دارد";
        }

        return duplicateMessage;
    }

    public bool CheckNextContractExist(long employeeId, DateTime startContract, DateTime endContract, long WorkshopId)
    {
        //var personelContracts = _context.Contracts.Where(x => x.EmployeeId == employeeId && x.WorkshopIds == WorkshopId && x.IsActiveString == "true")
        //    .OrderByDescending(x=>x.ContarctStart).ToList();
        //var checkLast = personelContracts.Select(x => x.ContarctStart).FirstOrDefault();
        var personelContracts1 = _context.Contracts.Any(x =>
            x.ContarctStart >= startContract && x.ContractEnd <= endContract && x.EmployeeId == employeeId && x.WorkshopIds == WorkshopId && x.IsActiveString == "true");
        var personelContracts2 = _context.Contracts.Any(x =>
            x.ContarctStart < startContract && x.ContractEnd <= endContract && x.ContractEnd > startContract && x.EmployeeId == employeeId && x.WorkshopIds == WorkshopId && x.IsActiveString == "true");
        var personelContracts3 = _context.Contracts.Any(x =>
            x.ContarctStart >= startContract && x.ContarctStart < endContract && x.ContractEnd > endContract && x.EmployeeId == employeeId && x.WorkshopIds == WorkshopId && x.IsActiveString == "true");

        if (personelContracts1 || personelContracts2 || personelContracts3)
        {
            return true;
        }
        else
        {
            return false;
        }

    }

    public bool CkeckBetween(long employeeId, DateTime EndOfContract, DateTime StartOfExtension, long WorkshopId)
    {
        var personelContracts = _context.Contracts.Any(x =>
            x.ContarctStart >= EndOfContract && x.ContractEnd <= StartOfExtension && x.EmployeeId == employeeId && x.WorkshopIds == WorkshopId && x.IsActiveString == "true");
        if (personelContracts)
        {
            return true;
        }
        else
        {
            return false;
        }
    }


    public class PeriodStartEnd
    {
        public string startC { get; set; }
        public string endC { get; set; }

        public int monthC { get; set; }
    }
    #region Client
    public bool Remove(long id)
    {

        using (var transaction = _context.Database.BeginTransaction())
        {
            try
            {
                //شرطها بعدا بایداضافه شود
                var contract = _context.Contracts.Where(x => x.id == id)?.FirstOrDefault();
                _context.Contracts.Remove(contract);
                _context.SaveChanges();
                transaction.Commit();
                return true;
            }
            catch (Exception)
            {
                transaction.Rollback();
                return false;
            }
        }
    }

    public List<ContractViweModel> SearchForClient(ContractSearchModel searchModel)
    {
        #region CheckValidtWorkshop

        var accountId = _authHelper.CurrentAccountId();
        var contracingPartyAcc = _context.ContractingPartyAccounts.FirstOrDefault(x => x.AccountId == accountId);
        if (contracingPartyAcc == null)
        {
            return new List<ContractViweModel>();
        }
        var employers =
            _context.Employers.Where(x => x.ContractingPartyId == contracingPartyAcc.PersonalContractingPartyId).Select(x => x.id).ToList();
        if (employers.Count < 1)
        {
            return new List<ContractViweModel>();
        }
        var workshopIds = _context.WorkshopEmployers.Where(x => employers.Contains(x.EmployerId))
            .Select(x => x.WorkshopId).ToList();
        var checkValid = workshopIds.Any(x => x == searchModel.WorkshopIds);
        if (!checkValid)
        {
            return new List<ContractViweModel>();
        }
        #endregion


        var query = _context.Contracts.Select(x => new ContractViweModel
        {
            Id = x.id,
            PersonnelCode = x.PersonnelCode,
            EmployerId = x.EmployerId,
            EmployeeId = x.EmployeeId,
            WorkshopIds = x.WorkshopIds,
            YearlySalaryId = x.YearlySalaryId,
            DayliWage = x.DayliWage,
            ContarctStart = x.ContarctStart.ToFarsi(),
            ContractEnd = x.ContractEnd.ToFarsi(),
            ContractStartGr = x.ContarctStart,
            ContractEndGr = x.ContractEnd,
            ContractNo = x.ContractNo,
            ArchiveCode = x.ArchiveCode,
            IsActiveString = x.IsActiveString,
            GetWorkDate = x.GetWorkDate.ToFarsi(),
            SetContractDate = x.SetContractDate.ToFarsi(),
            JobType = x.JobType,
            ContractType = x.ContractType,
            WorkshopAddress1 = x.WorkshopAddress1,
            WorkshopAddress2 = x.WorkshopAddress2,
            JobTypeId = x.JobTypeId,
            ConsumableItems = x.ConsumableItems,
            FamilyAllowance = x.FamilyAllowance,
            ContractPeriod = x.ContractPeriod,
            Signature = x.Signature,
            EmployerName = x.Employer.FullName,
            EmployeeName = x.Employee.FName + " " + x.Employee.LName,
            WorkshopName = x.Workshop.WorkshopName,
        }).Where(x => x.WorkshopIds == searchModel.WorkshopIds);

        if (searchModel.EmployeeId > 0)
            query = query.Where(x => x.EmployeeId == searchModel.EmployeeId);

        if (!string.IsNullOrWhiteSpace(searchModel.ContarctStart) && !string.IsNullOrWhiteSpace(searchModel.ContractEnd))
        {
            var start = searchModel.ContarctStart.ToGeorgianDateTime();
            var endd = searchModel.ContractEnd.ToGeorgianDateTime();
            query = query.Where(x =>
                x.ContractStartGr >= start && x.ContractEndGr <= endd);
        }
        else if (!string.IsNullOrWhiteSpace(searchModel.Year) && !string.IsNullOrWhiteSpace(searchModel.Month))
        {
            var y = searchModel.Year + "/" + searchModel.Month + "/01";
            string y2 = string.Empty;
            int month = Convert.ToInt32(searchModel.Month);
            int year = Convert.ToInt32(searchModel.Year);

            if (month <= 6)
            {
                y2 = $"{searchModel.Year}/{searchModel.Month}/31";
            }
            else if (month > 6 && month < 12)
            {
                y2 = $"{searchModel.Year}/{searchModel.Month}/30";
            }
            else if (month == 12)
            {
                switch (year)
                {
                    case 1346:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1350:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1354:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1358:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1362:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1366:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1370:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1375:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1379:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1383:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1387:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1391:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1395:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1399:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1403:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1408:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1412:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1416:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1420:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1424:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1428:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1432:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1436:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1441:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1445:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;

                    default:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/29";
                        break;

                }
            }

            var start = y.ToGeorgianDateTime();
            var end = y2.ToGeorgianDateTime();

            query = query.Where(x => x.ContractStartGr >= start && x.ContractStartGr < end && x.ContractEndGr > start && x.ContractEndGr <= end ||
                                     x.ContractStartGr <= start && x.ContractEndGr >= end || start <= x.ContractStartGr && end > x.ContractStartGr || end >= x.ContractEndGr && start < x.ContractEndGr);
        }


        if (!string.IsNullOrWhiteSpace(searchModel.Year) && string.IsNullOrWhiteSpace(searchModel.Month))
        {
            var startOfYear = searchModel.Year + "/01/01";
            var startOfyearGr = startOfYear.ToGeorgianDateTime();
            var endOfYear = $"{searchModel.Year}/12/01".FindeEndOfMonth();
            var endOfYearGr = endOfYear.ToGeorgianDateTime();

            query = query.Where(x => x.ContractStartGr >= startOfyearGr && x.ContractEndGr <= endOfYearGr);
        }

        if (searchModel.SearchAll)
            return query.OrderByDescending(x => x.Id).ToList();
        switch (searchModel.Sorting)
        {
            case "CreationDate-Max":
                return query.OrderByDescending(x => x.Id).Skip(searchModel.PageIndex).Take(30).ToList();
                break;
            case "CreationDate-Min":
                return query.OrderBy(x => x.Id).Skip(searchModel.PageIndex).Take(30).ToList();
                break;
            case "PersonelCode-Max":
                return query.OrderByDescending(x => x.PersonnelCode).Skip(searchModel.PageIndex).Take(30).ToList();
                break;
            case "PersonelCode-Min":
                return query.OrderBy(x => x.PersonnelCode).Skip(searchModel.PageIndex).Take(30).ToList();
                break;
            case "ContractStart-Min":
                return query.OrderBy(x => x.ContractStartGr).Skip(searchModel.PageIndex).Take(30).ToList();
                break;
            case "ContractStart-Max":
                return query.OrderByDescending(x => x.ContractStartGr).Skip(searchModel.PageIndex).Take(30).ToList();
                break;
            case "Signature-Min":
                return query.OrderByDescending(x => x.Signature == "0").Skip(searchModel.PageIndex).Take(30).ToList();
                break;
            case "Signature-Max":
                return query.OrderByDescending(x => x.Signature == "1").Skip(searchModel.PageIndex).Take(30).ToList();
                break;
            default: return query.OrderByDescending(x => x.Id).Skip(searchModel.PageIndex).Take(30).ToList();
        }


    }

    public async Task<PagedResult<GetContractListForClientResponse>> GetContractListForClient(GetContractListForClientRequest searchModel)
    {
        var workshopId = _authHelper.GetWorkshopId();
        var query = _context.Contracts
            .Where(c => c.WorkshopIds == workshopId);

        #region Search
        
        if (searchModel.EmployeeId > 0)
            query = query.Where(x => x.EmployeeId == searchModel.EmployeeId);
        if (!string.IsNullOrWhiteSpace(searchModel.StartDate) && string.IsNullOrWhiteSpace(searchModel.EndDate))
        {
            if (!searchModel.StartDate.TryToGeorgianDateTime(out var startDate))
                throw new BadRequestException("تاریخ شروع وارد شده معتبر نمی باشد.");
            
            if (!searchModel.EndDate.TryToGeorgianDateTime(out var endDate))
                throw new BadRequestException("تاریخ پایان وارد شده معتبر نمی باشد.");
            
            query = query.Where(x => x.ContarctStart <=endDate && x.ContractEnd >= startDate);
        }

        if (searchModel.Year>0 && searchModel.Month >0)
        {
            
            var startDateFa = $"{searchModel.Year:0000}/{searchModel.Month:00}/01";
            if (!startDateFa.TryToGeorgianDateTime(out var startDate))
                throw new BadRequestException("سال و ماه وارد شده معتبر نمی باشد.");
            
            if(!startDateFa.FindeEndOfMonth().TryToGeorgianDateTime(out var endDate))
                throw new BadRequestException("سال و ماه وارد شده معتبر نمی باشد.");
            
            query = query.Where(x => x.ContarctStart <=endDate && x.ContractEnd >= startDate);
        }

        if (searchModel.OrderType != null)
        {
            switch (searchModel.OrderType)
            {
                case ContractListOrderType.ByContractCreationDate:
                    query = query.OrderBy(x => x.CreationDate);
                    break;
                case ContractListOrderType.ByContractStartDate:
                    query = query.OrderBy(x => x.ContarctStart);
                    break;
                case ContractListOrderType.ByContractStartDateDescending:
                    query = query.OrderByDescending(x=>x.ContarctStart);
                    break;
                case ContractListOrderType.ByPersonnelCode:
                    query = query.OrderBy(x => x.PersonnelCode);
                    break;
                case ContractListOrderType.ByPersonnelCodeDescending:
                    query = query.OrderByDescending(x => x.PersonnelCode);
                    break;
                case ContractListOrderType.BySignedContract:
                    query = query.OrderByDescending(x => x.Signature == "1");
                    break;
                case ContractListOrderType.ByUnSignedContract:
                    query = query.OrderBy(x => x.Signature == "1");
                    break;
            }
        }
        else
        {
            query = query.OrderByDescending(x => x.id);
        }
        #endregion

        var pagedList =await query
            .ApplyPagination(searchModel.PageIndex, searchModel.PageSize).ToListAsync();

        var employeeIds = pagedList.Select(x => x.EmployeeId).ToList();
        
        var employees = await _context.Employees
            .Where(x => employeeIds.Contains(x.id)).Select(x => new
        {
            Id = x.id, 
            x.FullName
        }).ToListAsync();
        
        var result = new PagedResult<GetContractListForClientResponse>
        {
            TotalCount = await query.CountAsync(),
            List = pagedList.Select(c =>
            {
                var employeeFullName = employees
                    .FirstOrDefault(e => e.Id == c.EmployeeId)?.FullName ?? "";
                
                return new GetContractListForClientResponse
                {
                    Id = c.id,
                    PersonnelCode = c.PersonnelCode.ToString(),
                    ContractStart = c.ContarctStart.ToFarsi(),
                    ContractEnd = c.ContractEnd.ToFarsi(),
                    ContractNo = c.ContractNo,
                    IsSigned = c.Signature == "1",
                    EmployeeFullName = employeeFullName,
                    AvgWorkingHour = WeeklyHourConvertor(c.WorkingHoursWeekly),
                    DailyWage = c.DayliWage,
                    FamilyAllowance = c.FamilyAllowance
                };
            }).ToList()
        };

        return result;
    }

    public async Task<List<ContractPrintViewModel>> PrintAllAsync(List<long> ids)
    {
        var query =await _context.Contracts.Include(x => x.Employer)
            .Include(x => x.Employee).Where(x => ids.Contains(x.id))
            .ToListAsync();
        
        var workshopIds = query.Select(x => x.WorkshopIds).Distinct().ToList();
        
        var workshops = await _context.Workshops
            .Where(x => workshopIds.Contains(x.id))
            .ToListAsync();

        List<long> exceptionWorkshops = [516,63,38,39];
        var res = query.Select(x =>
        {
            var workshop = workshops.FirstOrDefault(w => w.id == x.WorkshopIds);

            var employerRes = new ContractPrintEmployerViewModel()
            {
                WorkshopName = workshop!.WorkshopName,
                Address =$"{workshop.State} - {workshop.City} - {workshop.Address}",
                LegalType = x.Employer.IsLegal == "حقیقی" ? LegalType.Real : LegalType.Legal,
                LegalEmployer = x.Employer.IsLegal == "حقیقی"
                    ? null
                    : new ContractPrintLegalEmployerViewModel()
                    {
                        NationalId = x.Employer.NationalId,
                        RegisterId = x.Employer.RegisterId,
                        CompanyName = x.Employer.LName,
                    },
                RealEmployer = x.Employer.IsLegal == "حقیقی"
                    ? new ContractPrintRealEmployerViewModel()
                    {
                        FullName = x.Employer.FullName,
                        IdNumber = x.Employer.IdNumber,
                        NationalCode = x.Employer.Nationalcode
                    }
                    : null,
                WorkshopCode = workshop.InsuranceCode

            };
            var employeeRes = new ContractPrintEmployeeViewModel()
            {
                Address =$"{x.Employee.State} - {x.Employee.City} - {x.Employee.Address}" ,
                FullName = x.Employee.FullName,
                IdNumber = x.Employee.IdNumber,
                NationalCode = x.Employee.NationalCode,
                DateOfBirth = x.Employee.DateOfBirth.ToFarsi(),
                FatherName = x.Employee.FatherName,
                LevelOfEducation = x.Employee.LevelOfEducation
            };

            var typeOfContract = new ContractPrintTypeOfContractViewModel()
            {
                ContarctStart = x.ContarctStart.ToFarsi(),
                ContractEnd = x.ContractEnd.ToFarsi(),
                JobName = x.JobType,
                ContractType = x.ContractType,
                SetContractDate = x.SetContractDate.ToFarsi(),
                WorkingHoursWeekly = WeeklyHourConvertor(x.WorkingHoursWeekly),
                WorkshopAddress = [x.WorkshopAddress1, x.WorkshopAddress2],
            };
            ContractPrintFeesViewModel fees= new ContractPrintFeesViewModel()
            {
                DailyWage = x.DayliWage,
                FamilyAllowance = x.FamilyAllowance,
                HousingAllowance = x.HousingAllowance,
                ConsumableItems = x.ConsumableItems,
            };
            return new ContractPrintViewModel()
            {
                Employer = employerRes,
                Employee = employeeRes,
                TypeOfContract = typeOfContract,
                Fees = fees,
                ContractNo = x.ContractNo,
                ConditionAndDetials = exceptionWorkshops.Contains(x.WorkshopIds) ? "بر اساس ماده 190 قانون کار جمهوری اسلامی ایران ، پرسنل اقرار مینماید کلیه مبالغ پیش بینی شده در قانون کار را وفق قرارداد منعقده دریافت مینماید. این مبالغ قسمتی بصورت مستقیم از سوی کارفرما و قسمتی بر اساس شرایط کارگاه از محل درآمد حاصله از مشتری اخذ میگردد . با توجه به شرایط کارگاه کلیه مبالغ بصورت واریز به حساب و وجه نقد رایج کشور ، تواما به پرسنل پرداخت میگردد. امضا تصفیه حساب دارای مبالغ ، توسط پرسنل نشانگر تصفیه قطعی ایشان میباشد.": "",

            };
        }).ToList();
        return res;
    }

    #endregion

    #region NewChangeByHeydari

    public OperationResult DeleteAllContarcts_Old(List<long> ids)
    {
        var op = new OperationResult();
        using (var transaction = _context.Database.BeginTransaction())
        {
            try
            {
                List<long> removeList = new List<long>();
                List<long> notRemoveList = new List<long>();

                foreach (var item in ids)
                {
                    if (_context.CheckoutSet.Any(x => x.ContractId == item))
                    {
                        notRemoveList.Add(item);
                    }
                    else if (_context.Contracts.Any(x => x.id == item && x.Signature == "0"))
                    {
                        var contract = _context.Contracts.Where(x => x.id == item)?.FirstOrDefault();
                        _context.Contracts.Remove(contract);
                        removeList.Add(item);
                    }
                    else
                    {
                        notRemoveList.Add(item);
                    }
                }
                _context.SaveChanges();

                transaction.Commit();
                if (removeList.Count() > 0 && notRemoveList.Count() > 0)
                    return op.Failed("<p class='text-success'>" + " تعداد " + removeList.Count() + "قرارداد با موفقیت حذف شد" + "</p><br/>" + "<p>" + " تعداد " + notRemoveList.Count() + "قرارداد به دلیل داشتن امضا یا تصفیه حساب، حذف نشد." + "</p>");
                else if (removeList.Count() > 0 && notRemoveList.Count() == 0)
                {
                    return op.Succcedded(-1, "حذف قراردادهای انتخاب شده با موفقیت انجام شد");
                }
                else if (removeList.Count() == 0 && notRemoveList.Count() > 0)
                {
                    return op.Failed("حذف تمامی قراردادهای انتخابی به دلیل داشتن امضا یا تصفیه حساب، انجام نشد.");
                }
                else
                {
                    return op.Succcedded(-1, "حذف با موفقیت انجام شد");
                }
            }
            catch (Exception)
            {
                transaction.Rollback();
                return op.Failed("حذف با خطا مواجه شد.");
            }
        }
    }
    public OperationResult DeleteAllContarcts(List<long> ids)
    {
        var op = new OperationResult();

        try
        {
            var contracts = _context.Contracts.Where(x => ids.Contains(x.id)).ToList();
            _context.Contracts.RemoveRange(contracts);
            _context.SaveChanges();
            return op.Succcedded(-1, "حذف با موفقیت شد.");
        }
        catch (Exception)
        {
            return op.Failed("حذف با خطا مواجه شد.");
        }
    }

    public OperationResult DeleteContarcts(long id)
    {
        var op = new OperationResult();

        try
        {

            var contract = _context.Contracts.Where(x => x.id == id)?.FirstOrDefault();
            _context.Contracts.Remove(contract);
            _context.SaveChanges();
            return op.Succcedded(-1, "حذف با موفقیت انجام شد.");

        }
        catch (Exception)
        {
            return op.Failed("حذف با خطا مواجه شد.");
        }

    }
    public List<long> CheckHasCheckout(List<long> ids)
    {
        List<long> notRemoveList = new List<long>();
        foreach (var item in ids)
        {

            if (_context.CheckoutSet.Any(x => x.ContractId == item && x.IsActiveString == "true"))
            {
                notRemoveList.Add(item);
            }
        }
        return notRemoveList;

    }
    public List<long> CheckHasSignature(List<long> ids)
    {

        List<long> notRemoveList = new List<long>();
        foreach (var item in ids)
        {
            if (_context.Contracts.Any(x => x.id == item && x.Signature == "1"))
            {
                notRemoveList.Add(item);
            }
        }
        return notRemoveList;

    }

    public List<ContractViweModel> SearchForMainContract(ContractSearchModel searchModel)
    {
        bool hasSearch = false;
        bool hasEmployeeOrWorkshopSearch = false;
        //var watch = System.Diagnostics.Stopwatch.StartNew();
        var AcountID = _authHelper.CurrentAccountId();
        var workshopAcounts = _context.WorkshopAccounts.Where(x => x.AccountId == AcountID)
            .Select(x => x.WorkshopId).ToList();
        var emp = _context.WorkshopEmployers.Where(x => x.EmployerId == searchModel.EmployerId)
            .Select(x => x.WorkshopId).ToList();
        //var employer = _context.Employers.Select(m => new EmployerViewModel
        //{
        //    Id = m.id,
        //    FullName = m.FullName,

            
        //}).ToList();
        var query = _context.Contracts.Select(x => new ContractViweModel
        {
            Id = x.id,
            PersonnelCode = x.PersonnelCode,
            EmployerId = x.EmployerId,
            EmployeeId = x.EmployeeId,
            WorkshopIds = x.WorkshopIds,
            YearlySalaryId = x.YearlySalaryId,
            DayliWage = x.DayliWage,
            ContarctStart = x.ContarctStart.ToFarsi(),
            ContractEnd = x.ContractEnd.ToFarsi(),
            ContractStartGr = x.ContarctStart,
            ContractEndGr = x.ContractEnd,
            ContractNo = x.ContractNo,
            ArchiveCode = x.ArchiveCode,
            IsActiveString = x.IsActiveString,
            GetWorkDate = x.GetWorkDate.ToFarsi(),
            SetContractDate = x.SetContractDate.ToFarsi(),
            JobType = x.JobType,
            ContractType = x.ContractType,
            WorkshopAddress1 = x.WorkshopAddress1,
            WorkshopAddress2 = x.WorkshopAddress2,
            JobTypeId = x.JobTypeId,
            ConsumableItems = x.ConsumableItems,
            FamilyAllowance = x.FamilyAllowance,
            ContractPeriod = x.ContractPeriod,
            Signature = x.Signature,
            EmployerName = x.Employer.FullName,
            EmployeeName = x.Employee.FName + " " + x.Employee.LName,
            WorkshopName = x.Workshop.WorkshopName,
            EmployeeFName = x.Employee.FName,
            EmployeeLName = x.Employee.LName,
            IsBlockCantracingParty = "false",

        });
        if (searchModel.WorkshopIds != 0)
        {
     
            hasEmployeeOrWorkshopSearch = true;
            query = query.Where(x => x.WorkshopIds == searchModel.WorkshopIds);

        }
        if (searchModel.EmployeeId != 0)
        {
      
            hasEmployeeOrWorkshopSearch = true;
            query = query.Where(x => x.EmployeeId == searchModel.EmployeeId);

        }
        if (searchModel.EmployerId != 0)
        {
            hasEmployeeOrWorkshopSearch = true;
            query = query.Where(x => emp.Contains(x.WorkshopIds));
        }

        if (!string.IsNullOrWhiteSpace(searchModel.ContractNo))
        {  //hasSearch = true;
            query = query.Where(x => x.ContractNo == searchModel.ContractNo);
        }

        if (!string.IsNullOrWhiteSpace(searchModel.ContractPeriod))
        {
            //hasSearch = true;
            query = query.Where(x => x.ContractPeriod == searchModel.ContractPeriod);
        }

        if (!string.IsNullOrWhiteSpace(searchModel.ContarctStart) &&
            !string.IsNullOrWhiteSpace(searchModel.ContractEnd))
        {
            hasSearch = true;
            var start = searchModel.ContarctStart.ToGeorgianDateTime();
            var endd = searchModel.ContractEnd.ToGeorgianDateTime();
            query = query.Where(x =>
                x.ContractStartGr >= start && x.ContractEndGr <= endd);
        }
        else if (!string.IsNullOrWhiteSpace(searchModel.Year) && !string.IsNullOrWhiteSpace(searchModel.Month))
        {
            //hasSearch = true;
            var y = searchModel.Year + "/" + searchModel.Month + "/01";
            string y2 = string.Empty;
            int month = Convert.ToInt32(searchModel.Month);
            int year = Convert.ToInt32(searchModel.Year);

            if (month <= 6)
            {
                y2 = $"{searchModel.Year}/{searchModel.Month}/31";
            }
            else if (month > 6 && month < 12)
            {
                y2 = $"{searchModel.Year}/{searchModel.Month}/30";
            }
            else if (month == 12)
            {
                switch (year)
                {
                    case 1346:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1350:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1354:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1358:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1362:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1366:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1370:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1375:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1379:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1383:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1387:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1391:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1395:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1399:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1403:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1408:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1412:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1416:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1420:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1424:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1428:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1432:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1436:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1441:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;
                    case 1445:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/30";
                        break;

                    default:
                        y2 = $"{searchModel.Year}/{searchModel.Month}/29";
                        break;

                }
            }

            var start = y.ToGeorgianDateTime();
            var end = y2.ToGeorgianDateTime();

            query = query.Where(x => x.ContractStartGr >= start && x.ContractStartGr < end && x.ContractEndGr > start && x.ContractEndGr <= end ||
                                     x.ContractStartGr <= start && x.ContractEndGr >= end || start <= x.ContractStartGr && end > x.ContractStartGr || end >= x.ContractEndGr && start < x.ContractEndGr);
        }

        if (searchModel.IsActiveString == null)
        {

            query = query.Where(x => x.IsActiveString == "true");
        }

        if (searchModel.IsActiveString == "false")
        {
            //hasSearch = true;
            query = query.Where(x => x.IsActiveString == "false");
        }
        else if (searchModel.IsActiveString == "both")
        {
            //hasSearch = true;
            query = query.Where(x => x.IsActiveString == "false" || x.IsActiveString == "true");
        }
        query = query.Where(e => workshopAcounts.Contains(e.WorkshopIds));


        if ((searchModel.EmployeeId != 0 || !string.IsNullOrEmpty(searchModel.EmployeeName)) && !string.IsNullOrWhiteSpace(searchModel.Year) && searchModel.WorkshopIds != 0)
        {
            hasSearch = true;
            if (!string.IsNullOrWhiteSpace(searchModel.Year) && string.IsNullOrWhiteSpace(searchModel.Month))
            {
                var startOfYear = searchModel.Year + "/01/01";
                var startOfyearGr = startOfYear.ToGeorgianDateTime();
                var endOfYear = $"{searchModel.Year}/12/01".FindeEndOfMonth();
                var endOfYearGr = endOfYear.ToGeorgianDateTime();
                query = query.Where(x => x.ContractStartGr >= startOfyearGr && x.ContractEndGr <= endOfYearGr);
            }
            else if (!string.IsNullOrEmpty(searchModel.EmployeeName))
            {
                query = query.Where(x =>
                        (!string.IsNullOrEmpty(x.EmployeeFName) && x.EmployeeFName.StartsWith(searchModel.EmployeeName)) ||
                        (!string.IsNullOrEmpty(x.EmployeeLName) && x.EmployeeLName.StartsWith(searchModel.EmployeeName)))
                    .OrderByDescending(x => x.Id);
            }

            return query.OrderByDescending(x => x.Id).ToList();
        }
        else
        {
            if (hasSearch)
                return query.OrderByDescending(x => x.Id).ToList();
            else if(hasEmployeeOrWorkshopSearch && !hasSearch)
                return query.OrderByDescending(x => x.ContractStartGr).ToList();
            else
            {
                return query.OrderByDescending(x => x.Id).Take(50).ToList();
            }
        }
    }
    #endregion

    #region Pooya
    public ContractViweModel GetByWorkshopIdEmployeeIdInDates(long workshopId, long employeeId, DateTime start, DateTime end)
    {
        var entity = _context.Contracts.FirstOrDefault(x => x.EmployeeId == employeeId && x.WorkshopIds == workshopId && x.ContractEnd.Date >= start.Date &&
                                                            x.ContarctStart.Date <= end.Date);
        if (entity == null)
            return new();
        return new ContractViweModel
        {
            ContractStartGr = entity.ContarctStart,
            ContractNo = entity.ContractNo,
            ContractEndGr = entity.ContractEnd,
            EmployeeId = entity.EmployeeId,
            WorkshopIds = workshopId,
            Id = entity.id
        };
    }

    public List<ContractViweModel> GetByWorkshopIdInDates(long workshopId, DateTime contractStart, DateTime contractEnd)
    {
        return _context.Contracts.Where(x => x.WorkshopIds == workshopId && x.ContractEnd >= contractStart && x.ContarctStart <= contractEnd).Select(x => new ContractViweModel
        {
            WorkshopIds = x.WorkshopIds,
            ContractStartGr = x.ContarctStart,
            ContractEndGr = x.ContractEnd,
            ContractNo = x.ContractNo,
        }).ToList();
    }
    #endregion
}