using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.Globalization;
using System.IO;
using System.Text.RegularExpressions;
using _0_Framework.Infrastructure;
using Microsoft.Extensions.WebEncoders.Testing;
using PersianTools.Core;
using static System.Net.Mime.MediaTypeNames;
using static Microsoft.EntityFrameworkCore.DbLoggerCategory.Database;
using Image = System.Drawing.Image;
using Newtonsoft.Json;
using Newtonsoft.Json.Bson;
using Microsoft.Extensions.Logging;
using System.IO.Compression;
using System.Linq;
using _0_Framework.Domain.CustomizeCheckoutShared.Base;
using System.ComponentModel.DataAnnotations;


namespace _0_Framework.Application;

public static class Tools
{

    public static string[] MonthNames =
        {"فروردین", "اردیبهشت", "خرداد", "تیر", "مرداد", "شهریور", "مهر", "آبان", "آذر", "دی", "بهمن", "اسفند"};

    public static string[] DayNames = { "شنبه", "یکشنبه", "دو شنبه", "سه شنبه", "چهار شنبه", "پنج شنبه", "جمعه" };
    public static string[] DayNamesG = { "یکشنبه", "دو شنبه", "سه شنبه", "چهار شنبه", "پنج شنبه", "جمعه", "شنبه" };

    /// <summary>
    /// نام ستون از جدول  مزد سنوات طبثه بندی را میگیرد و دیتای داخل آن ستون را برمیگرداند
    /// </summary>
    /// <param name="obj"></param>
    /// <param name="propertyName"></param>
    /// <returns></returns>
    public static double? GetDynamicDouble(object obj, string propertyName)
    {
        if (obj == null || string.IsNullOrWhiteSpace(propertyName))
            return null;

        var propertyInfo = obj.GetType().GetProperty(propertyName);
        if (propertyInfo == null)
            return null;

        var value = propertyInfo.GetValue(obj);
        if (value == null)
            return null;

        try
        {
            return Convert.ToDouble(value);
        }
        catch
        {
            return null;
        }
    }


    public static bool IsMobileValid(this string mobileNo)
    {
        if (mobileNo.Length < 11)
            return false;
        return Regex.IsMatch(mobileNo, "^((09))(\\d{9})$");
    }

    /// <summary>
    /// متد رند کننده مبلغ
    /// استفاده شده در بیمه
    /// </summary>
    /// <param name="value"></param>
    /// <returns></returns>
    public static double GetRoundDoubleValue(double value)
    {
        string strValue = value.ToString();
        if (strValue.IndexOf('.') > -1)
        {


            string a = strValue.Substring(strValue.IndexOf('.') + 1, 1);
            if (int.Parse(a) > 5)
            {
                return (Math.Round(value, MidpointRounding.ToPositiveInfinity));
            }
            else
            {
                return (Math.Round(value, MidpointRounding.ToNegativeInfinity));
            }
        }

        return value;
    }

    /// <summary>
    /// تاریخ شروع و تعداد ماه را میگیرد و تاریخ پایان قراردا را بر میگرداند
    /// </summary>
    /// <param name="startDate"></param>
    /// <param name="monthPlus"></param>
    /// <returns></returns>
    public static (DateTime endDateGr, string endDateFa) FindEndOfContract(string startDate, string monthPlus)
    {

        int startYear = Convert.ToInt32(startDate.Substring(0, 4));
        int startMonth = Convert.ToInt32(startDate.Substring(5, 2));
        int startDay = Convert.ToInt32(startDate.Substring(8, 2));
        var start = new PersianDateTime(startYear, startMonth, startDay);
        var end = (start.AddMonths(Convert.ToInt32(monthPlus))).AddDays(-1);
        return ($"{end}".ToGeorgianDateTime(), $"{end}");

    }

    /// <summary>
    /// دریافت روزهای کارکرد پرسنل در لیست بیمه ماه مشخص شده
    /// با کمک شروع بکار و ترک کار
    /// </summary>
    /// <param name="startWork"></param>
    /// <param name="leftWork"></param>
    /// <param name="startDate"></param>
    /// <param name="endDate"></param>
    /// <param name="employeeId"></param>
    /// <returns></returns>
    public static (int countWorkingDays, DateTime startWork, DateTime endWork, bool hasStartWorkInMonth, bool hasLeftWorkInMonth) GetEmployeeInsuranceWorkingDays(DateTime startWork, DateTime? leftWork, DateTime startDate,
        DateTime endDate, long employeeId)
    {
        DateTime start = startDate;
        DateTime end = endDate;
        bool startWorkInMonth = false;
        bool endWorkInMonth = false;

        //اگر شروع بکار پرسنل در ماه مشخص شده لیست بیمه بود
        if (startWork >= startDate)
        {
            start = startWork;
            startWorkInMonth = true;
        }

        if (leftWork == null)
            leftWork = DateTime.MinValue;
        //اگر ترک کار پرسنل در ماه مشخص شده لیست بیمه بود
        if (leftWork != DateTime.MinValue && leftWork.Value < endDate)
        {
            end = leftWork.Value;
            endWorkInMonth = true;
        }

        int countDays = (int)(end - start).TotalDays + 1;


        //روزهای کارکرد پرسنل با آی دی های زیر دستی تعریف شد
        switch (employeeId)
        {

            //case 3812://ثابت- کسری حاجی پور
            //    countWorkingDays = 15;
            //    break;
            case 40463://ثابت
                countDays = 10;
                break;
            case 40469://ثابت
                countDays = 7;
                break;
            //case 9950://ثابت
            // countDays = 15;
            //break;
            case 9640://ثابت
                countDays = 15;
                break;
            case 40998://ثابت
                countDays = 15;
                break;
            case 6219://ثابت
                countDays = 15;
                break;
                //case 7897://ثابت
                //    countWorkingDays = 15;
        }


        return (countDays, start, end, startWorkInMonth, endWorkInMonth);
    }
    /// <summary>
    /// محاسبه سن 
    /// </summary>
    /// <param name="startDate"></param>
    /// <param name="endDate"></param>
    /// <returns></returns>
    public static (int yearCount, int monthCount, int dayCount) GetAge(DateTime startDate, DateTime endDate)
    {

        var startFa = startDate.ToFarsi();
        int startYear = Convert.ToInt32(startFa.Substring(0, 4));
        int startMonth = Convert.ToInt32(startFa.Substring(5, 2));
        int startDay = Convert.ToInt32(startFa.Substring(8, 2));
        var start = new PersianDateTime(startYear, startMonth, startDay);


        var endFa = endDate.ToFarsi();
        int endYear = Convert.ToInt32(endFa.Substring(0, 4));
        int endMonth = Convert.ToInt32(endFa.Substring(5, 2));
        int endDay = Convert.ToInt32(endFa.Substring(8, 2));
        var end = new PersianDateTime(endYear, endMonth, endDay);
        int months = 0;
        int days = 0;
        int years = 0;

        var firstYearCounter = start.AddYears(1);
        //اگر سنش هنوز به یک سال نرسیده بود
        if (firstYearCounter > end)
        {
            start = start.AddYears(-1);

            var endMonthCounter = new PersianDateTime(end.Year, end.Month, start.Day);

            for (var monthCounter = start; monthCounter <= end; monthCounter = monthCounter.AddMonths(1))
            {
                if (monthCounter <= end)
                {
                    Console.ForegroundColor = ConsoleColor.Yellow;
                    Console.WriteLine("month : " + monthCounter);
                    months++;
                }

                if (monthCounter.Month == end.Month)
                {
                    var firstDayCounter = monthCounter.AddDays(1);
                    for (var dayCounter = firstDayCounter; dayCounter <= end; dayCounter = dayCounter.AddDays(1))
                    {
                        if (dayCounter <= end)
                        {
                            days++;
                            Console.ForegroundColor = ConsoleColor.Cyan;
                            Console.WriteLine("day : " + dayCounter);

                        }

                    }
                    months = months > 0 ? months - 1 : 0;
                    break;
                }



            }


        }
        else
        {
            for (var yearCouner = firstYearCounter; yearCouner <= end; yearCouner = yearCouner.AddYears(1))
            {

                if (yearCouner.Year <= end.Year)
                {
                    years++;
                    Console.ForegroundColor = ConsoleColor.DarkMagenta;
                    Console.WriteLine("year : " + yearCouner);
                }


                if (yearCouner.Year == end.Year)
                {

                    var endMonthCounter = new PersianDateTime(end.Year, end.Month, (yearCouner.Day > end.Day ? end.Day : yearCouner.Day));

                    if (yearCouner.Day <= end.Day)
                    {
                        endMonthCounter = end;

                    }
                    for (var monthCounter = yearCouner; monthCounter <= endMonthCounter; monthCounter = monthCounter.AddMonths(1))
                    {
                        if (monthCounter < end)
                        {
                            Console.ForegroundColor = ConsoleColor.Yellow;
                            Console.WriteLine("month : " + monthCounter);
                            months++;
                        }

                        if (monthCounter.Month == end.Month)
                        {
                            var firstDayCounter = monthCounter.AddDays(1);
                            if (yearCouner.Day > end.Day)
                            {

                                firstDayCounter = firstDayCounter.AddMonths(-1);
                            }
                            for (var dayCounter = firstDayCounter; dayCounter <= end; dayCounter = dayCounter.AddDays(1))
                            {
                                if (dayCounter <= end)
                                {
                                    days++;
                                    Console.ForegroundColor = ConsoleColor.Cyan;
                                    Console.WriteLine("day : " + dayCounter);

                                }

                            }

                            months = months > 0 ? months - 1 : 0;
                            break;
                        }


                    }

                }

            }
        }


        Console.ResetColor();
        Console.WriteLine($"old: [{years} year] ، [{months} month] ، [{days} day]");
        return (years, months, days);
    }

    public static string ToFarsi(this DateTime? date)
    {
        try
        {
            if (date != null) return date.Value.ToFarsi();
        }
        catch (Exception)
        {
            return "";
        }

        return "";
    }

    public static string ToFarsi(this DateTime date)
    {
        if (date == new DateTime()) return "";
        var pc = new PersianCalendar();
        return $"{pc.GetYear(date)}/{pc.GetMonth(date):00}/{pc.GetDayOfMonth(date):00}";
    }
    public static string ToFarsiMonth(this DateTime date)
    {
        if (date == new DateTime()) return "";
        var pc = new PersianCalendar();
        return $"{pc.GetMonth(date)}";
    }
    /// <summary>
    /// این متد تاریخ میلادی را گرفته و ماه 31 یا 30 روزه را تشخیص میدهد، ماه اسفند 30 روزه برمگیردد
    /// </summary>
    /// <param name="date"></param>
    /// <returns></returns>
    public static int CountMonthDays(this DateTime date)
    {
        if (date == new DateTime()) return 0;
        var pc = new PersianCalendar();

        return pc.GetMonth(date) switch
        {
            1 => 31,
            2 => 31,
            3 => 31,
            4 => 31,
            5 => 31,
            6 => 31,

            7 => 30,
            8 => 30,
            9 => 30,
            10 => 30,
            11 => 30,
            12 => 30,
            _ => 0,

        };
    }

    public static string ToFarsiYear2(this DateTime date)
    {
        if (date == new DateTime()) return "";
        var pc = new PersianCalendar();
        var year = pc.GetYear(date).ToString();
        string y1 = string.Empty;
        string y2 = string.Empty;
        string sum = string.Empty;
        for (int i = 0; i < year.Length; i++)
        {

            if (year[i] == 2)
            {
                y1 += year[i];
            }

            if (year[i] == 3)
            {
                y2 += year[i];
            }

        }

        sum = y1 + y2;
        return sum;
    }
    public static string ToFarsiYear(this DateTime date)
    {
        if (date == new DateTime()) return "";
        var pc = new PersianCalendar();

        return $"{pc.GetYear(date)}";
    }
    public static string ToDiscountFormat(this DateTime date)
    {
        if (date == new DateTime()) return "";
        return $"{date.Year}/{date.Month}/{date.Day}";
    }

    public static string GetTime(this DateTime date)
    {
        return $"_{date.Hour:00}_{date.Minute:00}_{date.Second:00}";
    }

    public static string ToFarsiFull(this DateTime date)
    {
        var pc = new PersianCalendar();
        return
            $"{pc.GetYear(date)}/{pc.GetMonth(date):00}/{pc.GetDayOfMonth(date):00}  {date.Hour:00}:{date.Minute:00}:{date.Second:00}";
    }

    private static readonly string[] Pn = { "۰", "۱", "۲", "۳", "۴", "۵", "۶", "۷", "۸", "۹" };
    private static readonly string[] En = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" };

    public static string ToEnglishNumber(this string strNum)
    {
        var cash = strNum;
        for (var i = 0; i < 10; i++)
            cash = cash.Replace(Pn[i], En[i]);
        return cash;
    }

    public static string ToPersianNumber(this int intNum)
    {
        var chash = intNum.ToString();
        for (var i = 0; i < 10; i++)
            chash = chash.Replace(En[i], Pn[i]);
        return chash;
    }

    public static DateTime? FromFarsiDate(this string InDate)
    {
        if (string.IsNullOrEmpty(InDate))
            return null;

        var spited = InDate.Split('/');
        if (spited.Length < 3)
            return null;

        if (!int.TryParse(spited[0].ToEnglishNumber(), out var year))
            return null;

        if (!int.TryParse(spited[1].ToEnglishNumber(), out var month))
            return null;

        if (!int.TryParse(spited[2].ToEnglishNumber(), out var day))
            return null;
        var c = new PersianCalendar();
        return c.ToDateTime(year, month, day, 0, 0, 0, 0);
    }


    public static DateTime ToGeorgianDateTime(this string persianDate)
    {
        try
        {
            persianDate = persianDate.ToEnglishNumber();
            var year = Convert.ToInt32(persianDate.Substring(0, 4));
            var month = Convert.ToInt32(persianDate.Substring(5, 2));
            var day = Convert.ToInt32(persianDate.Substring(8, 2));

            return new DateTime(year, month, day, new PersianCalendar());


        }
        catch (Exception e)
        {
            return new DateTime(3000, 12, 20, new PersianCalendar());
        }

    }

    public static DateTime ToGeorgian(this string persianDate)
    {
        persianDate = persianDate.ToEnglishNumber();
        var year = Convert.ToInt32(persianDate.Substring(0, 4));
        var month = 01;
        var day = 01;
        return new DateTime(year, month, day, new PersianCalendar());
    }
    public static string ToMoney(this double myMoney)
    {

        return myMoney.ToString("N0", CultureInfo.CreateSpecificCulture("fa-ir"));
    }

    /// <summary>
    /// اگر مبلغ صفر باشد خط تیره برمیگرداند
    /// </summary>
    /// <param name="myMoney"></param>
    /// <returns></returns>
    public static string ToMoneyCheckZero(this double myMoney)
    {
        if (myMoney == 0)
            return "-";
        return myMoney.ToString("N0", CultureInfo.CreateSpecificCulture("fa-ir"));
    }

    /// <summary>
    /// اگر مبلغ صفر یا نال باشد خط تیره برمیگرداند
    /// </summary>
    /// <param name="myMoney"></param>
    /// <returns></returns>
    public static string ToMoneyCheckZeroNullable(this double? myMoney)
    {
        if (myMoney == 0 || myMoney == null)
            return "-";
        return myMoney?.ToString("N0", CultureInfo.CreateSpecificCulture("fa-ir"));
    }
    public static string ToMoneyNullable(this double? myMoney)
    {

        return myMoney?.ToString("N0", CultureInfo.CreateSpecificCulture("fa-ir"));
    }
    public static string ToDoubleMoney(this string myMoney)
    {
        string bb = string.Empty;

        for (int x = 0; x < myMoney.Length; x++)
        {
            if (char.IsDigit(myMoney[x]))
                bb += myMoney[x];
        }

        if (bb.Length > 0)
        {
            return bb;
        }
        else
        {
            return "0";
        }



    }
    public static double MoneyToDouble(this string myMoney)
    {
        string bb = string.Empty;
        bool isNegative = false;

        try
        {
            if (!string.IsNullOrWhiteSpace(myMoney))
            {
                for (int x = 0; x < myMoney.Length; x++)
                {
                    if (char.IsDigit(myMoney[x]))
                    {
                        bb += myMoney[x];
                    }
                    else if (myMoney[x] == '-' && bb.Length == 0)
                    {
                        // اگر علامت منفی قبل از اولین عدد آمد، در نظر بگیر
                        isNegative = true;
                    }
                }

                if (bb.Length > 0)
                {
                    double res = double.Parse(bb);
                    return isNegative ? -res : res;
                }
                else
                {
                    return 0;
                }
            }
            else
            {
                return 0;
            }
            
        }
        catch (Exception)
        {

            return 0;
        }
    }
    public static string ToFileName(this DateTime date)
    {
        return $"{date.Year:0000}-{date.Month:00}-{date.Day:00}-{date.Hour:00}-{date.Minute:00}-{date.Second:00}";
    }

    public static string FindeEndOfMonth(this string date)
    {
        string y2 = string.Empty;
        var year = Convert.ToInt32(date.Substring(0, 4));
        var month = Convert.ToInt32(date.Substring(5, 2));
        var YearD = date.Substring(0, 4);
        var MonthD = date.Substring(5, 2);
        if (month <= 6)
        {
            y2 = $"{YearD}/{MonthD}/31";
        }
        else if (month > 6 && month < 12)
        {
            y2 = $"{YearD}/{MonthD}/30";
        }
        else if (month == 12)
        {
            switch (year)
            {
                case 1346:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1350:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1354:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1358:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1362:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1366:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1370:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1375:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1379:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1383:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1387:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1391:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1395:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1399:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1403:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1408:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1412:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1416:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1420:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1424:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1428:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1432:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1436:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1441:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1445:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;

                default:
                    y2 = $"{YearD}/{MonthD}/29";
                    break;

            }
        }

        return y2;
    }

    /// <summary>
    /// تاریخ شمسی میگیرد و پایان ماه را به میلادی برمیگرداند
    /// </summary>
    /// <param name="date"></param>
    /// <returns></returns>
    public static DateTime FindeEndOfMonthReturnGr(this string date)
    {
        string y2 = string.Empty;
        var year = Convert.ToInt32(date.Substring(0, 4));
        var month = Convert.ToInt32(date.Substring(5, 2));
        var YearD = date.Substring(0, 4);
        var MonthD = date.Substring(5, 2);
        if (month <= 6)
        {
            y2 = $"{YearD}/{MonthD}/31";
        }
        else if (month > 6 && month < 12)
        {
            y2 = $"{YearD}/{MonthD}/30";
        }
        else if (month == 12)
        {
            switch (year)
            {
                case 1346:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1350:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1354:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1358:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1362:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1366:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1370:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1375:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1379:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1383:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1387:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1391:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1395:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1399:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1403:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1408:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1412:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1416:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1420:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1424:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1428:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1432:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1436:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1441:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;
                case 1445:
                    y2 = $"{YearD}/{MonthD}/30";
                    break;

                default:
                    y2 = $"{YearD}/{MonthD}/29";
                    break;

            }
        }

        return y2.ToGeorgianDateTime();
    }
    /// <summary>
    /// تعداد روزهای سال را برمیگرداند
    /// اگر کبیسهد بود سال 366 روزه برمیگرداند
    /// اگر کبیسهد نبود سال 365 روزه برمیگرداند
    /// </summary>
    /// <param name="date"></param>
    /// <returns></returns>
    public static int YearTotalDays(this string date)
    {
        int y2 = 366;
        var year = Convert.ToInt32(date.Substring(0, 4));


        switch (year)
        {
            case 1346:
                y2 = 367;
                break;
            case 1350:
                y2 = 367;
                break;
            case 1354:
                y2 = 367;
                break;
            case 1358:
                y2 = 367;
                break;
            case 1362:
                y2 = 367;
                break;
            case 1366:
                y2 = 367;
                break;
            case 1370:
                y2 = 367;
                break;
            case 1375:
                y2 = 367;
                break;
            case 1379:
                y2 = 367;
                break;
            case 1383:
                y2 = 367;
                break;
            case 1387:
                y2 = 367;
                break;
            case 1391:
                y2 = 367;
                break;
            case 1395:
                y2 = 367;
                break;
            case 1399:
                y2 = 367;
                break;
            case 1403:
                y2 = 367;
                break;
            case 1408:
                y2 = 367;
                break;
            case 1412:
                y2 = 367;
                break;
            case 1416:
                y2 = 367;
                break;
            case 1420:
                y2 = 367;
                break;
            case 1424:
                y2 = 367;
                break;
            case 1428:
                y2 = 367;
                break;
            case 1432:
                y2 = 367;
                break;
            case 1436:
                y2 = 367;
                break;
            case 1441:
                y2 = 367;
                break;
            case 1445:
                y2 = 367;
                break;

            default:
                y2 = 366;
                break;

        }


        return y2;
    }

    public static int BetweenDateGeorgianToDay(DateTime dateStart, DateTime? dateEnd)
    {
        DateTime end = DateTime.Now;
        if (dateEnd != null)
        {
            end = (DateTime)dateEnd;
        }
        return (int)(end - dateStart).TotalDays;
    }

    public static string GetMonthByNumber(this string value)
    {

        if (value == "01")
        {
            return "فروردین";
        }
        else if (value == "02")
        {
            return "اردیبهشت";
        }
        else if (value == "03")
        {
            return "خرداد";
        }
        else if (value == "04")
        {
            return "تیر";
        }
        else if (value == "05")
        {
            return "مرداد";
        }
        else if (value == "06")
        {
            return "شهریور";
        }
        else if (value == "07")
        {
            return "مهر";
        }
        else if (value == "08")
        {
            return "آبان";
        }
        else if (value == "09")
        {
            return "آذر";
        }
        else if (value == "10")
        {
            return "دی";
        }
        else if (value == "11")
        {
            return "بهمن";
        }
        else
            return "اسفند";

    }

    public static string RestTimeSplit(this string restTime)
    {
        string result = string.Empty;

        if (restTime?.Length >= 2)
        {
            result = restTime.Substring(0, 2);
            if (result == "00")
                result = "0";
        }
        else
        {
            result = "0";
        }


        return result;
    }

    public static string NationalCodeValid(this string nationalCode)
    {
        try
        {
            char[] chArray = nationalCode.ToCharArray();
            int[] numArray = new int[chArray.Length];
            var cunt = chArray.Length;
            for (int i = 0; i < chArray.Length; i++)
            {
                numArray[i] = (int)char.GetNumericValue(chArray[i]);
            }

            int num2 = numArray[9];
            switch (nationalCode)
            {
                case "0000000000":
                case "1111111111":
                case "2222222222":
                case "3333333333":
                case "4444444444":
                case "5555555555":
                case "6666666666":
                case "7777777777":
                case "8888888888":
                case "9999999999":

                    return "incorrect";
            }

            int num3 =
                ((((((((numArray[0] * 10) + (numArray[1] * 9)) + (numArray[2] * 8)) + (numArray[3] * 7)) +
                    (numArray[4] * 6)) + (numArray[5] * 5)) + (numArray[6] * 4)) + (numArray[7] * 3)) +
                (numArray[8] * 2);
            int num4 = num3 - ((num3 / 11) * 11);
            if ((((num4 == 0) && (num2 == num4)) || ((num4 == 1) && (num2 == 1))) ||
                ((num4 > 1) && (num2 == Math.Abs((int)(num4 - 11)))) && cunt <= 10)
            {
                return "valid";
            }
            else
            {
                return "invalid";
            }
        }
        catch (Exception)
        {
            return "lessThan10";

        }

    }
    public static string RestTimeMinSplit(this string restTime)
    {
        string result = string.Empty;

        if (restTime?.Length > 2)
        {
            result = restTime.Substring(3, 2);
            if (result == "00")
                result = "0";

        }
        else
        {
            result = "0";
        }


        return result;
    }

    public static List<long> ExtractNumbers(this string input)
    {
        List<long> numbers = new List<long>();
        string pattern = @"\d+"; // Matches one or more digits

        MatchCollection matches = Regex.Matches(input, pattern);

        foreach (Match match in matches)
        {
            if (long.TryParse(match.Value, out long number))
            {
                numbers.Add(number);
            }
        }

        return numbers;
    }
    public static int ExtractIntNumbers(this string input)
    {
        int numbers = 0;
        string num = "";
        string pattern = @"\d+"; // Matches one or more digits

        MatchCollection matches = Regex.Matches(input, pattern);

        foreach (Match match in matches)
        {
            if (int.TryParse(match.Value, out int number))
            {
                num += $"{number}";
            }
        }

        try
        {
            numbers = Convert.ToInt32(num);
        }
        catch (Exception e)
        {
            return 0;
        }
     
        return numbers;
    }
    public static string ToFarsiMonthByNumber(this string value)
    {
        if (value == "") return "";
        string result = "";
        switch (value)
        {
            case "1":
            case "01":
                result = "فروردین";
                break;
            case "2":
            case "02":
                result = "اردیبهشت";
                break;
            case "3":
            case "03":
                result = "خرداد";
                break;
            case "4":
            case "04":
                result = "تیر";
                break;
            case "5":
            case "05":
                result = "مرداد";
                break;
            case "6":
            case "06":
                result = "شهریور";
                break;
            case "7":
            case "07":
                result = "مهر";
                break;
            case "8":
            case "08":
                result = "آبان";
                break;
            case "9":
            case "09":
                result = "آذر";
                break;
            case "10":
                result = "دی";
                break;
            case "11":
                result = "بهمن";
                break;
            case "12":
                result = "اسفند";
                break;
            default:
                result = "";
                break;
        }

        return result;
    }
    public static string ToFarsiMonthByIntNumber(this int value)
    {
        if (value == 0) return "";
        string result = "";
        switch (value)
        {
            case 1:
                result = "فروردین";
                break;
            case 2:
                result = "اردیبهشت";
                break;
            case 3:
                result = "خرداد";
                break;
            case 4:
                result = "تیر";
                break;
            case 5:
                result = "مرداد";
                break;
            case 6:
                result = "شهریور";
                break;
            case 7:
                result = "مهر";
                break;
            case 8:
                result = "آبان";
                break;
            case 9:
                result = "آذر";
                break;
            case 10:
                result = "دی";
                break;
            case 11:
                result = "بهمن";
                break;
            case 12:
                result = "اسفند";
                break;
            default:
                result = "";
                break;
        }

        return result;
    }

    #region Vafa
    public static string ToFarsiWithoutYear(this DateTime date)
    {
        if (date == new DateTime()) return "";
        var pc = new PersianCalendar();
        return $"{pc.GetMonth(date):00}/{pc.GetDayOfMonth(date):00}";
    }
    public static int ToMonthByStringValue(this string value)
    {
        if (value == "") return 0;
        int result = 0;
        switch (value)
        {
            case "فروردین":
                result = 1;
                break;
            case "اردیبهشت":
                result = 2;
                break;
            case "خرداد":
                result = 3;
                break;
            case "تیر":
                result = 4;
                break;
            case "مرداد":
                result = 5;
                break;
            case "شهریور":
                result = 6;
                break;
            case "مهر":
                result = 7;
                break;
            case "آبان":
                result = 8;
                break;
            case "آذر":
                result = 9;
                break;
            case "دی":
                result = 10;
                break;
            case "بهمن":
                result = 11;
                break;
            case "اسفند":
                result = 12;
                break;
            default:
                result = 0;
                break;
        }

        return result;
    }

    public static string ColorPercent(this int value)
    {
        string color = "";

        var redDark = "#B91C1C";
        var redLight = "#EF4444";

        var orangeDark = "#F59E0B";
        var orangeLight = "#FBBF24";

        var limeDark = "#81CB0F";
        var limeLight = "#A3E635";

        switch (value)
        {
            case <= 16:
                color = redDark;
                break;
            case <= 33:
                color = redLight;
                break;
            case <= 49:
                color = orangeDark;
                break;
            case <= 66:
                color = orangeLight;
                break;
            case <= 83:
                color = limeLight;
                break;
            case <= 100:
                color = limeDark;
                break;
            default:
                color = "";
                break;
        }
        return color;
    }

    public static double RoundMoney(this double value)
    {
        var valueLength = (((int)value).ToString()).Length;
        var checkZero = (((int)value).ToString()).Substring(1, 1);
        int digitValue = 0;
        int digitLentgh = 0;
        int d = 0;
        if ((int)value == 10499677)
        {
            Console.WriteLine(90);
        }
        switch (valueLength)
        {
            case 6:
                digitValue = 5000;
                digitLentgh = 100000;
                d = 1000;
                break;
            case 7:
                digitValue = 50000;
                digitLentgh = 1000000;
                d = 10000;
                break;
            case 8:
                digitValue = checkZero == "0" ? 50000 : 500000;
                digitLentgh = checkZero == "0" ? 100000 : 10000000;
                d = 100000;
                break;

        }

        int result = 0;
        int rightDigits = (int)(value % digitLentgh);


        //if (rightDigits < digitValue)
        //{
        //    result = (int)(value / d) * d;
        //}
        //else
        //{
        //    result = (int)(value / d + 1) * d;
        //}
        result = (int)(value / d + 1) * d;
        return result;
    }

    public static string ToMoneyToman(this double myMoney)
    {
        myMoney = myMoney / 10;
        return myMoney.ToString("N0", CultureInfo.CreateSpecificCulture("fa-ir"));
    }

    public static PersianDateTime ToPersianDateTime(this DateTime date)
    {
        var persianDate = date.ToFarsi();
        var year = Convert.ToInt32(persianDate.Substring(0, 4));
        var month = Convert.ToInt32(persianDate.Substring(5, 2));
        var day = Convert.ToInt32(persianDate.Substring(8, 2));
        return new PersianDateTime(year, month, day);
    }

    public static string ResizeImage(string imagePath, int width, int height)
    {
        using (var srcImage = Image.FromFile(imagePath))
        {
            var newImage = new Bitmap(width, height);
            using (var graphics = Graphics.FromImage(newImage))
            {
                graphics.CompositingQuality = CompositingQuality.HighSpeed;
                graphics.InterpolationMode = InterpolationMode.Bicubic;
                graphics.SmoothingMode = SmoothingMode.HighSpeed;
                graphics.DrawImage(srcImage, 0, 0, width, height);
            }

            using (var memoryStream = new MemoryStream())
            {
                newImage.Save(memoryStream, ImageFormat.Jpeg);
                return Convert.ToBase64String(memoryStream.ToArray());
            }
        }
    }

    public static PersianDateTime ToFirstDayOfNextMonth(this DateTime date)
    {
        var pc = new PersianCalendar();
        var year = pc.GetYear(date);
        var month = pc.GetMonth(date);

        if (month == 12)
        {
            year += 1;
            month = 1;
        }
        else
        {
            month += 1;
        }

        return new PersianDateTime(year, month, 1);

    }
    #endregion

    #region Safa

    public static string GetContentTypeImage(string extension)
    {
        if (!extension.StartsWith("."))
        {
            extension = "." + extension;
        }

        return extension.ToLower() switch
        {
            ".jpg" => "image/jpeg",
            ".jpeg" => "image/jpeg",
            ".png" => "image/png",
            ".gif" => "image/gif",
            ".bmp" => "image/bmp",
            ".svg" => "image/svg+xml",
            ".ico" => "image/x-icon",
            _ => "",
        };
    }

    public static string GetContentType(string extension)
    {

        // Ensure the extension starts with a dot
        if (!extension.StartsWith("."))
        {
            extension = "." + extension;
        }

        // Use switch expression to return the appropriate content type
        return extension.ToLower() switch
        {
            ".txt" => "text/plain",
            ".htm" => "text/html",
            ".html" => "text/html",
            ".css" => "text/css",
            ".js" => "application/javascript",
            ".json" => "application/json",
            ".xml" => "application/xml",
            ".pdf" => "application/pdf",
            ".zip" => "application/zip",
            ".rar" => "application/x-rar-compressed",
            ".tar" => "application/x-tar",
            ".mp3" => "audio/mpeg",
            ".wav" => "audio/wav",
            ".mp4" => "video/mp4",
            ".avi" => "video/x-msvideo",
            ".doc" => "application/msword",
            ".docx" => "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
            ".xls" => "application/vnd.ms-excel",
            ".xlsx" => "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            ".ppt" => "application/vnd.ms-powerpoint",
            ".pptx" => "application/vnd.openxmlformats-officedocument.presentationml.presentation",
            _ => "application/octet-stream",
        };
    }

    #endregion
    public static string ConvertToEnglish(this string value)
    {
        if (string.IsNullOrEmpty(value))
            return value;

        string EnglishNumbers = "";
        for (int i = 0; i < value.Length; i++)
        {
            if (Char.IsDigit(value[i]))
            {
                EnglishNumbers += char.GetNumericValue(value, i);
            }
            else
            {
                EnglishNumbers += value[i].ToString();
            }
        }
        return EnglishNumbers;
    }

    public static DateTime ExtractTimeFromDbbackup(this string value)
    {
        DateTime dateTime = new DateTime();
        var parts = value.Split('-');
        if (parts.Length >= 4 && parts[1].Length == 4 && parts[2].Length == 2 && parts[3].Length == 2 && parts[4].Length == 2 && parts[5].Length >= 2)
        {
            var part5 = parts[5].Substring(0, 2);


            try
            {
                PersianCalendar pc = new PersianCalendar();
                dateTime = pc.ToDateTime(int.Parse(parts[1]), int.Parse(parts[2]), int.Parse(parts[3]), int.Parse(parts[4]), int.Parse(part5), 0, 0, 0);

            }
            catch (Exception e)
            {


            }

        }
        //var year = value.Substring(10, 4);
        //var month = value.Substring(15, 2);
        //var day = value.Substring(18, 2);
        //var persianDate = year + "/" + month + "/" + day;
        //var georgianDate = persianDate.ToGeorgianDateTime();
        //var hourString = value.Substring(21, 2);
        //int hour = hourString.ExtractIntNumbers();

        //var result = new DateTime(georgianDate.Year, georgianDate.Month, georgianDate.Day, hour, 1, 1);
        return dateTime;
    }

    public static DateTime ExtractTimeFromInsurancebackup(this string value)
    {
        var year = value.Substring(14, 4);
        var month = value.Substring(19, 2);
        var day = value.Substring(22, 2);
        var persianDate = year + "/" + month + "/" + day;
        var georgianDate = persianDate.ToGeorgianDateTime();
        var hourString = value.Substring(25, 2);
        int hour = hourString.ExtractIntNumbers();

        var result = new DateTime(georgianDate.Year, georgianDate.Month, georgianDate.Day, hour, 1, 1);
        return result;
    }

    public static string FindeEndOfYear(this string date)
    {
        var year = Convert.ToInt32(date.Substring(0, 4));
        var month = Convert.ToInt32(date.Substring(5, 2));
        var day = Convert.ToInt32(date.Substring(8, 2));

        var start = new PersianDateTime(year, month, day);
        var startAddYear = start.AddMonths(11);
        var monthStr = $"{startAddYear.Month}";
        if (monthStr.Length < 2)
            monthStr = $"0{monthStr}";
        var lastMonth = $"{startAddYear.Year}/{monthStr}/01";
        var end = lastMonth.FindeEndOfMonth();
        return end;

    }

    public static string CalculateLeaveHoursAndDays(string paidLeaveType, string leaveHourses)
    {
        string leaveHoursResult = "";
        if (paidLeaveType == "ساعتی")
        {
            var leaveH = TimeSpan.Parse(leaveHourses);
            var hours = (int)leaveH.TotalHours;
            var minutes = (int)leaveH.TotalMinutes % 60;
            if (hours > 0 && minutes > 0)
            {
                leaveHoursResult = hours + " ساعت و " + minutes + " دقیقه";
            }
            else if (hours > 0 && minutes == 0)
            {
                leaveHoursResult = hours + " ساعت";
            }
            else if (hours == 0 && minutes > 0)
            {
                leaveHoursResult = minutes + " دقیقه";
            }
        }
        else
        {
            leaveHoursResult = leaveHourses + " روز";
        }

        return leaveHoursResult;
    }

    public static string ComputationOfHoursAndMinutes(double data)
    {
        int hours = (int)Math.Floor(data);
        double remaining = data - hours;
        int minutes = (int)(remaining * 60);

        string result;
        if (minutes == 0)
        {
            result = hours + " س";
        }
        else
        {
            result = hours + " س " + minutes + " د";
        }

        return result;
    }

    public static bool CheckValidHm(string input)
    {
        if (string.IsNullOrWhiteSpace(input))
            return true;
        string pattern = @"^([2][0-3]|[1][0-9]|[0-9]|[0][0-9])([:][0-5][0-9])$";

        var match = Regex.Match(input, pattern);
        if (!match.Success)
            return false;
        return true;
    }

    /// <summary>
    /// چک میکند که در دو شیفت استاتیک تداخل زمانی وجود دارد یا خیر
    /// چک میکند که آیا ساعات وارد شده ولید هستند یا خیر
    /// </summary>
    /// <param name="start1"></param>
    /// <param name="end1"></param>
    /// <param name="start2"></param>
    /// <param name="end2"></param>
    /// <returns></returns>
    public static bool InterferenceTime(string start1, string end1, string start2, string end2)
    {
        if (!CheckValidHm(start1))
            return true;

        if (!CheckValidHm(end1))
            return true;

        if (!CheckValidHm(start2))
            return true;

        if (!CheckValidHm(end2))
            return true;

        //اگه دو شیفت نبود
        if (string.IsNullOrWhiteSpace(start1) || string.IsNullOrWhiteSpace(start2))
            return false;


        try
        {
            var start1Gr = Convert.ToDateTime(start1);
            var end1Gr = Convert.ToDateTime(end1);

            if (end1Gr < start1Gr)
                end1Gr = end1Gr.AddDays(1);

            var start2Gr = Convert.ToDateTime(start2);
            var end2Gr = Convert.ToDateTime(end2);


            start2Gr = new DateTime(end1Gr.Year, end1Gr.Month, end1Gr.Day, start2Gr.Hour, start2Gr.Minute,
                start2Gr.Second);


            end2Gr = new DateTime(end1Gr.Year, end1Gr.Month, end1Gr.Day, end2Gr.Hour, end2Gr.Minute,
                end2Gr.Second);
            if (end2Gr < start2Gr)
                end2Gr = end2Gr.AddDays(1);

            var diff = (end1Gr - start1Gr).Add((end2Gr - start2Gr));
            if (diff > new TimeSpan(24,0,0))
                return true;

            if (start2Gr <= end1Gr)
                return true;

            return false;
        }
        catch (Exception)
        {

            return true;
        }

        
    }
    public static DateTime FindFirstDayOfMonthGr(this DateTime date)
    {
        var pc = new PersianCalendar();
        return ($"{pc.GetYear(date)}/{pc.GetMonth(date):00}/01").ToGeorgianDateTime();
    }
    #region Mahan


    public static bool IsvalidIban(this string iban)
    {
        return Regex.IsMatch(iban, @"^IR[0-9]{24}$");
    }
    public static bool IsValidCardNumber(this string cardNumber)
    {
        return Regex.IsMatch(cardNumber, @"^[0-9]{16}$");
    }
    /// <summary>
    /// این متد حروف عربی را به فارسی در میاورد. مثال: علي را به علی تبدیل میکند
    /// </summary>
    /// <param name="text"></param>
    /// <returns></returns>
    public static string ToPersian(this string text)
    {
        var res = "";
        foreach (var @char in text)
        {

            if (@char == char.Parse("ي"))
                res += "ی";
            else if (@char == char.Parse("ك"))
                res += "ک";
            else
                res += @char;
        }
        return res;
    }

    /// <summary>
    /// این متد سعی میکند رشته را به تاریخ برگرداند و یک بول و دیت تایم برمیگرداند
    /// </summary>
    /// <param name="persianDate">تاریخ شمسی</param>
    /// <param name="georgianDateTime">تاریخ</param>
    /// <returns></returns>
    public static bool TryToGeorgianDateTime(this string persianDate, out DateTime georgianDateTime)
    {
        if (string.IsNullOrWhiteSpace(persianDate))
        {
            georgianDateTime = new DateTime(3000, 12, 20, new PersianCalendar());
            return false;
        }
        persianDate = persianDate.ToEnglishNumber();
        try
        {
            var year = Convert.ToInt32(persianDate.Substring(0, 4));
            var month = Convert.ToInt32(persianDate.Substring(5, 2));
            var day = Convert.ToInt32(persianDate.Substring(8, 2));

            georgianDateTime = new DateTime(year, month, day, new PersianCalendar());
            return true;
        }
        catch
        {
            georgianDateTime = new DateTime(3000, 12, 20, new PersianCalendar());
            return false;
        }
    }

    public static string FindFirstDayOfMonth(this DateTime date)
    {
        var pc = new PersianCalendar();
        return $"{pc.GetYear(date)}/{pc.GetMonth(date):00}/01";
    }
    public static string ToFarsiDuration(this string date)
    {
        var today = DateTime.Now.ToFarsi();
        var year = Convert.ToInt32(today.Substring(0, 4));
        var month = Convert.ToInt32(today.Substring(5, 2));
        var day = Convert.ToInt32(today.Substring(8, 2));
        var todayPersianDate = new PersianDateTime(year, month, day);

        var planYear = Convert.ToInt32(date.Substring(0, 4));
        var planMonth = Convert.ToInt32(date.Substring(5, 2));
        var planDay = Convert.ToInt32(date.Substring(8, 2));
        var planPersianDate = new PersianDateTime(planYear, planMonth, planDay);

        if (planPersianDate > todayPersianDate)
        {
            var countDay = 0;
            var counMonth = 0;
            var nextMonth = new PersianDateTime(todayPersianDate).AddMonths(1);
            for (var start = todayPersianDate; start <= planPersianDate; start = start.AddDays(1))
            {
                countDay++;
                if (start == nextMonth)
                {
                    counMonth++;
                    nextMonth = new PersianDateTime(start).AddMonths(1);
                    countDay = 0;
                }
            }

            if (counMonth > 0)
            {
                if (countDay == 0)
                {
                    return $"{counMonth} ماه";
                }
                return $"{counMonth}ماه و {countDay} روز";
            }
            else
            {
                return $"{countDay}روز";
            }
        }
        else
        {
            return "";
        }
    }

    public static string ToFarsiDuration2(this string date)
    {
        var persianCalendar = new System.Globalization.PersianCalendar();
        var today = DateTime.Now;

        // Convert today's Gregorian date to Persian date
        var todayYear = persianCalendar.GetYear(today);
        var todayMonth = persianCalendar.GetMonth(today);
        var todayDay = persianCalendar.GetDayOfMonth(today);

        var todayPersianDate = new DateTime(todayYear, todayMonth, todayDay, persianCalendar);

        // Parse the target Persian date from the input string
        var planYear = int.Parse(date.Substring(0, 4));
        var planMonth = int.Parse(date.Substring(5, 2));
        var planDay = int.Parse(date.Substring(8, 2));

        var planPersianDate = new DateTime(planYear, planMonth, planDay, persianCalendar);

        if (planPersianDate > todayPersianDate)
        {
            // Calculate the exact difference in years, months, and days
            int yearDifference = planYear - todayYear;
            int monthDifference = planMonth - todayMonth;
            int dayDifference = planDay - todayDay;

            if (dayDifference < 0)
            {
                monthDifference--;
                dayDifference += persianCalendar.GetDaysInMonth(todayYear, todayMonth);
            }

            if (monthDifference < 0)
            {
                yearDifference--;
                monthDifference += 12;
            }

            // Construct the duration string
            var duration = "";
            if (yearDifference > 0)
            {
                duration += $"{yearDifference} سال ";
            }

            if (monthDifference > 0)
            {
                duration += $"{monthDifference} ماه ";
            }

            if (dayDifference > 0)
            {
                duration += $"{dayDifference} روز";
            }

            return duration.Trim();
        }
        else
        {
            return "";
        }
    }
    public static string SerializeToBson(object obj)
    {
        using var memoryStream = new MemoryStream();
        using (BsonDataWriter bsonWriter = new BsonDataWriter(memoryStream))
        {
            JsonSerializer serializer = new JsonSerializer();
            serializer.Serialize(bsonWriter, obj);
        }
        byte[] bsonData = memoryStream.ToArray();
        return Convert.ToBase64String(bsonData);
    }
    //بیسان هایی که  بصورت لیست بودند استخراج میشود
    public static List<T> DeserializeFromBsonList<T>(string base64Data)
    {
        byte[] data = Convert.FromBase64String(base64Data);

        using MemoryStream memoryStream = new MemoryStream(data);
        using BsonDataReader reader = new BsonDataReader(memoryStream);
        reader.ReadRootValueAsArray = true;
        JsonSerializer serializer = new JsonSerializer();
        return serializer.Deserialize<List<T>>(reader);
    }
    //بیسان هایی که  بصورت تکی بودند استخراج میشود
    public static T DeserializeFromBson<T>(string base64Data)
    {
        byte[] bsonData = Convert.FromBase64String(base64Data);
        using MemoryStream memoryStream = new MemoryStream(bsonData);
        using BsonDataReader bsonReader = new BsonDataReader(memoryStream);
        JsonSerializer serializer = new JsonSerializer();
        return serializer.Deserialize<T>(bsonReader);
    }

    public static TimeOnly CalculateOffset(ICollection<CustomizeSifts> shiftDetailsRegularShifts)
    {
        if (!shiftDetailsRegularShifts.Any())
        {
            return TimeOnly.MinValue;
        }
        var date = new DateOnly();
        var firstStartShift = new DateTime(date, shiftDetailsRegularShifts.MinBy(x => x.Placement).StartTime);
        var lastEndShift = new DateTime(date, shiftDetailsRegularShifts.MaxBy(x => x.Placement).EndTime);
        if (lastEndShift > firstStartShift)
            firstStartShift = firstStartShift.AddDays(1);
        var offSet = (firstStartShift - lastEndShift).Divide(2);
        return TimeOnly.FromDateTime(lastEndShift.Add(offSet));
    }
    public static DateTime GetNextDayOfWeek(this DateTime date, DayOfWeek dayOfWeek)
    {
        int numberOfNextDayOfWeek = ((int)dayOfWeek - (int)date.DayOfWeek + 7) % 7;
        return date.AddDays(numberOfNextDayOfWeek == 0 ? 7 : numberOfNextDayOfWeek);
    }


    //این متد آخر همان روز را به صورت دیت تایم برمیگرداند
    public static DateTime ToEndDayOfGeorgianDateTime(this string persianDate)
    {
        persianDate = persianDate.ToEnglishNumber();
        try
        {
            var year = Convert.ToInt32(persianDate.Substring(0, 4));
            var month = Convert.ToInt32(persianDate.Substring(5, 2));
            var day = Convert.ToInt32(persianDate.Substring(8, 2));

            var res = new DateTime(year, month, day, new PersianCalendar());
            res = res.AddHours(23);
            res = res.AddMinutes(59);
            res = res.AddSeconds(59);

            return res;

        }
        catch (Exception e)
        {
            return new DateTime(3000, 12, 20, new PersianCalendar());
        }

    }
    //تبدیل به تاریخ با ساعت
    public static DateTime ToGeorgianDateWithTime(this string persianDate, string persianTime)
    {
        persianDate = persianDate.ToEnglishNumber();
        try
        {
            var year = Convert.ToInt32(persianDate.Substring(0, 4));
            var month = Convert.ToInt32(persianDate.Substring(5, 2));
            var day = Convert.ToInt32(persianDate.Substring(8, 2));



            var hour = int.Parse(persianTime.Substring(0, 2));
            var minute = int.Parse(persianTime.Substring(3, 2));

            var res = new DateTime(year, month, day, new PersianCalendar());
            res = res.AddHours(hour);
            res = res.AddMinutes(minute);
            return res;

        }
        catch (Exception e)
        {
            return new DateTime(3000, 12, 20, new PersianCalendar());
        }

    }

    public static string DayOfWeeKToPersian(this DayOfWeek dayOfWeek)
    {
        return dayOfWeek switch
        {
            DayOfWeek.Friday => "جمعه",
            DayOfWeek.Monday => "دوشنبه",
            DayOfWeek.Saturday => "شنبه",
            DayOfWeek.Sunday => "یکشنبه",
            DayOfWeek.Thursday => "پنجشنبه",
            DayOfWeek.Tuesday => "سه شنبه",
            DayOfWeek.Wednesday => "چهارشنبه",
            _ => ""
        };
    }

    public static bool IsInvalidDateTime(this DateTime date)
    {
        return date == new DateTime(3000, 12, 20, new PersianCalendar());

    }





    #endregion

    #region Pooya
    /// <summary>
    /// محاسبه روز های هر ماه شمسی
    /// </summary>
    /// <param name="date">تاریخ روزی از ماه</param>
    public static int CountPersianMonthDays(this DateTime date)
    {
        DateTime currentMonthDate, nextMonthDate;
        currentMonthDate = date.FindFirstDayOfMonth().ToGeorgianDateTime();
        FindFirstDayOfNextMonth(date, out nextMonthDate);

        return ((int)(nextMonthDate.Date - currentMonthDate.Date).TotalDays);
    }

    public static string FindFirstDayOfNextMonth(this DateTime date, out DateTime nextMonthDate)
    {
        var dateFa = date.ToFarsi();
        int year = Convert.ToInt32(dateFa.Substring(0, 4));
        int month = Convert.ToInt32(dateFa.Substring(5, 2));
        int nextMonth;
        int nextMonthYear;
        if (month == 12)
        {
            nextMonthYear = year + 1;
            nextMonth = 1;
        }
        else
        {
            nextMonthYear = year;
            nextMonth = month + 1;
        }
        nextMonthDate = new DateTime(nextMonthYear, nextMonth, 1, new PersianCalendar());
        return $"{nextMonthYear:0000}/{nextMonth:00}/01";
    }


    /// <summary>
    /// اضافه یا کم کردن ماه، توجه داشته باشید خروجی متد همیشه یکم ماه می باشد
    /// </summary>
    public static string AddMonthsFa(this DateTime date, int count, out DateTime result)
    {
        var dateFa = date.ToFarsi();
        int year = Convert.ToInt32(dateFa.Substring(0, 4));
        int month = Convert.ToInt32(dateFa.Substring(5, 2));

        int newMonth;
        int newYear;

        //add operation
        if (count >= 0)
        {
            newYear = year;
            while (month + count > 12)
            {
                newYear += 1;
                count -= 12;
            }
            newMonth = month + count;

        }

        //subtract operation
        else
        {
            newYear = year;
            while (month + count < 1)
            {
                newYear -= 1;
                count += 12;
            }
            newMonth = month + count;
        }
        result = new DateTime(newYear, newMonth, 1, new PersianCalendar());
        return $"{newYear:0000}/{newMonth:00}/01";

    }


    public static DateTime GetUndefinedDateTime()
    {
        return new DateTime(2121, 03, 21);
    }

    public static bool IsDateUndefined(this DateTime date)
    {
        return date == new DateTime(2121, 03, 21);
    }
    public static string ToFarsiHoursAndMinutes(int hours, int minutes, string emptyValue = "")
    {

        string message = emptyValue;
        if (hours > 0 && minutes > 0)
        {

            message = hours + " " + "ساعت و" + " " + minutes + " " + "دقیقه";
        }
        else if (hours > 0 && minutes == 0)
        {

            message = hours + " " + "ساعت ";
        }
        else if (hours == 0 && minutes > 0)
        {

            message = minutes + " " + "دقیقه";
        }

        return message;
    }
    public static string ToFarsiHoursAndMinutes(this TimeSpan timeSpan, string emptyValue = "")
    {
        var hours = (int)timeSpan.TotalHours;
        var minutes = timeSpan.Minutes;
        string message = emptyValue;
        if (hours > 0 && minutes > 0)
        {

            message = hours + " " + "ساعت و" + " " + minutes + " " + "دقیقه";
        }
        else if (hours > 0 && minutes == 0)
        {

            message = hours + " " + "ساعت ";
        }
        else if (hours == 0 && minutes > 0)
        {

            message = minutes + " " + "دقیقه";
        }

        return message;
    }
    public static string ToFarsiDaysAndHoursAndMinutes(this TimeSpan timeSpan, string emptyValue = "")
    {
        var hours = (int)timeSpan.TotalHours;
        var minutes = timeSpan.Minutes;
        var days = hours / 24;
        hours = hours % 24;
        string message = "";

        if (days > 0)
            message += days + " " + "روز";
        if (hours > 0)
            if (message == "")
                message += hours + " " + "ساعت";
            else
                message += " و " + hours + " " + "ساعت";
        if (minutes > 0)
            if (message == "")
                message += minutes + " " + "دقیقه";
            else
                message += " و " + minutes + " " + "دقیقه";

        if (message == "")
            message = emptyValue;
        return message;
    }

    public static bool ArePropertiesEqual<T>(this T obj1, T obj2)
    {
        // If either object is null, they can't be equal
        if (obj1 == null || obj2 == null)
            return false;

        // Get the type of the objects
        var type = typeof(T);

        // Iterate through each property
        foreach (var property in type.GetProperties())
        {
            // Get the values of the current property for both objects
            var value1 = property.GetValue(obj1);
            var value2 = property.GetValue(obj2);

            // If both values are null, they are considered equal
            if (value1 == null && value2 == null)
                continue;

            // If one value is null, but the other isn't, they are not equal
            if (value1 == null || value2 == null)
                return false;

            // If values are not equal, return false
            if (!value1.Equals(value2))
                return false;
        }

        // If all properties are equal, return true
        return true;
    }

    #endregion

    #region Davoodi

    public static List<string> GetDaysBetweenDateGeorgian(DateTime startDate, DateTime? endDate)
    {
        var days = new List<string>();

        if (endDate == null)
            endDate = DateTime.Now;

        var persianStartDate = new MD.PersianDateTime.Standard.PersianDateTime(startDate);
        var persianEndDate = new MD.PersianDateTime.Standard.PersianDateTime(endDate);


        while (persianEndDate - persianStartDate >= TimeSpan.FromDays(0))
        {
            days.Add(persianStartDate.ToShortDateString());
            persianStartDate = persianStartDate.AddDays(1);
        }

        return days;
    }

    public static int GetWorkingDaysDifference(DateTime? fromDate, DateTime? toDate)
    {
        //var workingDays = PersianDateExtensions.GetWorkingDays(new PersianDateTime(fromDate.ToFarsi()), new PersianDateTime(toDate.ToFarsi()), true);
        var workingDays = PersianDateExtensions.GetWorkingDays((DateTime)fromDate, (DateTime)toDate, true);


        if (fromDate > toDate)
            workingDays *= -1;


        return workingDays;
    }



    #endregion
}