using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using _0_Framework.Application;
using _0_Framework.Application.Sms;
using _0_Framework.Application.UID;
using _0_Framework.Exceptions;
using Company.Domain.ContarctingPartyAgg;
using Company.Domain.InstitutionPlanAgg;
using Company.Domain.TemporaryClientRegistrationAgg;
using CompanyManagment.App.Contracts.InstitutionContract;
using CompanyManagment.App.Contracts.InstitutionPlan;
using CompanyManagment.App.Contracts.TemporaryClientRegistration;
using IPE.SmsIrClient.Models.Results;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using PersianTools.Core;
using static Microsoft.EntityFrameworkCore.DbLoggerCategory.Database;

namespace CompanyManagment.Application;

public class TemporaryClientRegistrationApplication : ITemporaryClientRegistrationApplication
{
    private readonly IContractingPartyTempRepository _contractingPartyTempRepository;
    private readonly IPersonalContractingPartyRepository _personalContractingPartyRepository;
    private readonly IUidService _uidService;
    private readonly IWorkshopTempRepository _workshopTempRepository;
    private readonly IPlanPercentageRepository _planPercentageRepository;
    private readonly IWorkshopServicesTempRepository _workshopServicesTempRepository;
    private readonly IInstitutionContractTempRepository _institutionContractTempRepository;
    private readonly ISmsService _smsService;

    public TemporaryClientRegistrationApplication(IContractingPartyTempRepository contractingPartyTempRepository,
        IPersonalContractingPartyRepository personalContractingPartyRepository, IUidService uidService,
        IWorkshopTempRepository workshopTempRepository, IPlanPercentageRepository planPercentageRepository,
        IWorkshopServicesTempRepository workshopServicesTempRepository,
        IInstitutionContractTempRepository institutionContractTempRepository, ISmsService smsService)
    {
        _contractingPartyTempRepository = contractingPartyTempRepository;
        _personalContractingPartyRepository = personalContractingPartyRepository;
        _uidService = uidService;
        _workshopTempRepository = workshopTempRepository;
        _planPercentageRepository = planPercentageRepository;
        _workshopServicesTempRepository = workshopServicesTempRepository;
        _institutionContractTempRepository = institutionContractTempRepository;
        _smsService = smsService;
    }

    /// <summary>
    /// احراز هویت
    /// </summary>
    /// <param name="nationalCode"></param>
    /// <param name="dateOfBirth"></param>
    /// <param name="mobile"></param>
    /// <returns></returns>
    public async Task<OperationResult<ContractingPartyTempViewModel>> CreateContractingPartyTemp(string nationalCode,
        string dateOfBirth, string mobile)
    {
        var op = new OperationResult<ContractingPartyTempViewModel>();

        #region Validations

        if (string.IsNullOrWhiteSpace(nationalCode) || string.IsNullOrWhiteSpace(dateOfBirth) ||
            string.IsNullOrWhiteSpace(mobile))
            return op.Failed("هیچ یک از فیلد ها نمیتواند خالی باشد");


        if (nationalCode.NationalCodeValid() != "valid")
            return op.Failed("کد ملی نا معتبر است");

        if (!dateOfBirth.IsPersianDateValid())
            return op.Failed("تاریخ تولد نا معتبر است");

        if (!mobile.IsMobileValid())
            return op.Failed("شماره همراه نا معتبر است");

        #endregion


        var getExistContractingParty =
            await _contractingPartyTempRepository.CheckExistOrAuthenticated(nationalCode, dateOfBirth);

        //اگر طرف حساب قبلا در دیتابیس وجود داشت
        if (getExistContractingParty)
        {
            return op.Failed("طرف حساب با این مشخصات در سیستم وجود دارد");
        }
        //اگر طرف حساب وجود نداشت
        else
        {
            //دریافت اطلاعات طرف حساب موقت که قبلا ایجاد شده 
            var getExistTemp = _contractingPartyTempRepository.GetByNationalCode(nationalCode);

            var dateOfBirthGr = dateOfBirth.ToGeorgianDateTime();


            //اگر طرف حساب موقت قبلا ایجاد شده دیتای آن را برمیگرداند
            if (getExistTemp != null)
            {
                var institutionContractTemp = await
                    _institutionContractTempRepository.GetInstitutionContractTemp(0, getExistTemp.Id);

                if (institutionContractTemp != null)
                {
                    if (institutionContractTemp.RegistrationStatus == InstitutionContractTempStatus.Completed)
                        return op.Failed("شما قبلا ثبت نام خود را تکمیل نموده اید");
                }

                if (getExistTemp.DateOfBirth != dateOfBirthGr)
                    return op.Failed("تاریخ تولد مطابقت ندارد");
                if (getExistTemp.Phone != mobile)
                    return op.Failed("شما قبلا با شماره همراه دیگری ثبت نام نموده اید");
                return op.Succcedded(getExistTemp);
            }

            //چک کردن مطابقت شماره همراه و کد ملی
            var isMachMobilAndNationalCode = await _uidService.IsMachPhoneWithNationalCode(nationalCode, mobile);
            if (isMachMobilAndNationalCode == null)
                return op.Failed("خطا در سرویس احراز هویت");
            if (!isMachMobilAndNationalCode.IsMatched)
                return op.Failed("شماره همراه وارد شده با کد ملی مطابقت ندارد");

            //دریافت اطلاعات احراز هویت
            var apiRespons = await _uidService.GetPersonalInfo(nationalCode, dateOfBirth);

            if (apiRespons == null)
                return op.Failed("خطا در سرویس احراز هویت");
            if (apiRespons.ResponseContext.Status.Code != 0)
                return op.Failed($"{apiRespons.ResponseContext.Status.Message}");

            var idNumber = apiRespons.IdentificationInformation.ShenasnamehNumber == "0"
                ? apiRespons.IdentificationInformation.NationalId
                : apiRespons.IdentificationInformation.ShenasnamehNumber;

            //ایجاد طرف حساب موقت
            var createTemp = new ContractingPartyTemp(apiRespons.BasicInformation.FirstName,
                apiRespons.BasicInformation.LastName, nationalCode, idNumber, mobile,
                apiRespons.BasicInformation.FatherName, "", "", "",
                apiRespons.IdentificationInformation.ShenasnameSeri,
                apiRespons.IdentificationInformation.ShenasnameSerial, apiRespons.BasicInformation.GenderEnum,
                dateOfBirthGr);
            await _contractingPartyTempRepository.CreateAsync(createTemp);
            await _contractingPartyTempRepository.SaveChangesAsync();

            var result = new ContractingPartyTempViewModel();
            result.Id = createTemp.id;
            result.FName = createTemp.FName;
            result.LName = createTemp.LName;
            result.DateOfBirthFa = dateOfBirth;
            result.FatherName = createTemp.FatherName;
            result.IdNumberSerial = createTemp.IdNumberSerial;
            result.IdNumber = idNumber;

            return op.Succcedded(result);
        }
    }

    /// <summary>
    /// تکمیل اطلاعات
    /// </summary>
    /// <param name="id"></param>
    /// <param name="state"></param>
    /// <param name="city"></param>
    /// <param name="address"></param>
    /// <returns></returns>
    public async Task<OperationResult> UpdateAddress(long id, string state, string city, string address)
    {
        var op = new OperationResult();
        var contractingPartyTemp = _contractingPartyTempRepository.Get(id);

        if (string.IsNullOrWhiteSpace(state) || string.IsNullOrWhiteSpace(city) || string.IsNullOrWhiteSpace(address))
            return op.Failed("اطلاعات ادرس را تکمیل کنید");

        contractingPartyTemp.UpdateAddress(state, city, address);
        await _contractingPartyTempRepository.SaveChangesAsync();

        return op.Succcedded();
    }

    /// <summary>
    /// دریافت کارگاه های ذخیره شده
    /// </summary>
    /// <param name="contractingPartyTempId"></param>
    /// <returns></returns>
    public Task<List<WorkshopTempViewModel>> GetWorkshopTemp(long contractingPartyTempId)
    {
        return _workshopTempRepository.GetWorkshopTemp(contractingPartyTempId);
    }

    /// <summary>
    /// ایجاد یا ویرایش کارگاه و سرویس های آن
    /// </summary>
    /// <param name="command"></param>
    /// <returns></returns>
    public async Task<OperationResult> CreateOrUpdateWorkshopTemp(List<WorkshopTempViewModel> command,
        long contractingPartyTempId)
    {
        var op = new OperationResult();
        var updateWorkshopList = command.Where(x => x.Id > 0).ToList();
        var createNewWorkshopList = command.Where(x => x.Id == 0).ToList();

        if (updateWorkshopList.Count == 0 && createNewWorkshopList.Count == 0)
            return op.Failed("هیچ مجموعه ای ایجاد نشده است");
        var oldWorkshops = await _workshopTempRepository.GetWorkshopTemp(contractingPartyTempId);

        #region Update

        if (updateWorkshopList.Count > 0)
        {
            var updateListIds = updateWorkshopList.Select(x => x.Id).ToList();
            var oldWorkshopsIds = oldWorkshops.Select(x => x.Id).ToList();
            var exceptWorkshops = oldWorkshopsIds.Except(updateListIds).ToList();
            if (exceptWorkshops.Any())
                await _workshopTempRepository.RemoveWorkshopTemps(exceptWorkshops);


            foreach (var workshop in updateWorkshopList)
            {
                if (string.IsNullOrWhiteSpace(workshop.WorkshopName))
                    return op.Failed("نام مجموعه نمی تواند خالی باشد");
                if (workshop.CountPerson == 0)
                    op.Failed($"تعداد پرسنل مجوعه {workshop.WorkshopName} صفر است");
                if (workshop.ContractAndCheckout == false && workshop.CustomizeCheckout == false &&
                    workshop.RollCall == false && workshop.Insurance == false)
                    op.Failed($"برای مجموعه {workshop.WorkshopName} هیچ سرویسی انتخاب نشده است");
                var existWorkshops = _workshopTempRepository.Get(workshop.Id);

                if (existWorkshops != null)
                {
                    if (workshop.ContractAndCheckout)
                        workshop.ContractAndCheckoutInPerson = true;
                    if (workshop.Insurance)
                        workshop.InsuranceInPerson = true;

                    //دریافت مبالغ سرویس ها
                    var plan = _planPercentageRepository.GetInstitutionPlanForWorkshop(workshop);
                    if (plan.OnlineAndInPersonSumAmountDouble > 0)
                    {
                        //ویرایش مشخصات کارگاه
                        existWorkshops.Edit(workshop.WorkshopName, workshop.CountPerson,
                            plan.OnlineAndInPersonSumAmountDouble);
                        await _workshopTempRepository.SaveChangesAsync();

                        //حذف سرویس های قبلی
                        _workshopServicesTempRepository.RemoveServices(workshop.Id);

                        //سرویس قرداد
                        if (workshop.ContractAndCheckout)
                            await _workshopServicesTempRepository.CreateAsync(
                                new WorkshopServicesTemp("ContractAndCheckout", workshop.CountPerson, workshop.Id));
                        //سرویس خدمات حضوری قرارداد
                        if (workshop.ContractAndCheckoutInPerson)
                            await _workshopServicesTempRepository.CreateAsync(
                                new WorkshopServicesTemp("ContractAndCheckoutInPerson", workshop.CountPerson,
                                    workshop.Id));

                        //سرویس بیمه
                        if (workshop.Insurance)
                            await _workshopServicesTempRepository.CreateAsync(
                                new WorkshopServicesTemp("Insurance", workshop.CountPerson, workshop.Id));
                        //سرویس خدمات حضوری بیمه
                        if (workshop.InsuranceInPerson)
                            await _workshopServicesTempRepository.CreateAsync(
                                new WorkshopServicesTemp("InsuranceInPerson", workshop.CountPerson, workshop.Id));

                        //سرویس حضورغیاب
                        if (workshop.RollCall)
                            await _workshopServicesTempRepository.CreateAsync(
                                new WorkshopServicesTemp("RollCall", workshop.CountPerson, workshop.Id));
                        //سرویس فیش غیر رسمی
                        if (workshop.CustomizeCheckout)
                            await _workshopServicesTempRepository.CreateAsync(
                                new WorkshopServicesTemp("CustomizeCheckout", workshop.CountPerson, workshop.Id));

                        await _workshopServicesTempRepository.SaveChangesAsync();
                    }
                }
            }
        }

        #endregion

        #region Create

        if (createNewWorkshopList.Count > 0)
        {
            foreach (var workshop in createNewWorkshopList)
            {
                if (string.IsNullOrWhiteSpace(workshop.WorkshopName))
                    return op.Failed("نام مجموعه نمی تواند خالی باشد");
                if (workshop.CountPerson == 0)
                    op.Failed($"تعداد پرسنل مجوعه {workshop.WorkshopName} صفر است");
                if (workshop.ContractAndCheckout == false && workshop.CustomizeCheckout == false &&
                    workshop.RollCall == false && workshop.Insurance == false)
                    op.Failed($"برای مجموعه {workshop.WorkshopName} هیچ سرویسی انتخاب نشده است");

                if (workshop.ContractAndCheckout)
                    workshop.ContractAndCheckoutInPerson = true;
                if (workshop.Insurance)
                    workshop.InsuranceInPerson = true;

                //دریافت مبالغ سرویس ها
                var plan = _planPercentageRepository.GetInstitutionPlanForWorkshop(workshop);
                if (plan.OnlineAndInPersonSumAmountDouble > 0)
                {
                    var createNewWorkshopTemp = new WorkshopTemp(workshop.WorkshopName, workshop.CountPerson,
                        workshop.ContractingPartyTempId, plan.OnlineAndInPersonSumAmountDouble);
                    await _workshopTempRepository.CreateAsync(createNewWorkshopTemp);
                    await _workshopTempRepository.SaveChangesAsync();


                    //سرویس قرداد
                    if (workshop.ContractAndCheckout)
                        await _workshopServicesTempRepository.CreateAsync(
                            new WorkshopServicesTemp("ContractAndCheckout", workshop.CountPerson,
                                createNewWorkshopTemp.id));
                    //سرویس خدمات حضوری قرارداد
                    if (workshop.ContractAndCheckoutInPerson)
                        await _workshopServicesTempRepository.CreateAsync(
                            new WorkshopServicesTemp("ContractAndCheckoutInPerson", workshop.CountPerson,
                                createNewWorkshopTemp.id));

                    //سرویس بیمه
                    if (workshop.Insurance)
                        await _workshopServicesTempRepository.CreateAsync(
                            new WorkshopServicesTemp("Insurance", workshop.CountPerson, createNewWorkshopTemp.id));
                    //سرویس خدمات حضوری بیمه
                    if (workshop.InsuranceInPerson)
                        await _workshopServicesTempRepository.CreateAsync(
                            new WorkshopServicesTemp("InsuranceInPerson", workshop.CountPerson,
                                createNewWorkshopTemp.id));

                    //سرویس حضورغیاب
                    if (workshop.RollCall)
                        await _workshopServicesTempRepository.CreateAsync(
                            new WorkshopServicesTemp("RollCall", workshop.CountPerson, createNewWorkshopTemp.id));
                    //سرویس فیش غیر رسمی
                    if (workshop.CustomizeCheckout)
                        await _workshopServicesTempRepository.CreateAsync(
                            new WorkshopServicesTemp("CustomizeCheckout", workshop.CountPerson,
                                createNewWorkshopTemp.id));

                    await _workshopServicesTempRepository.SaveChangesAsync();
                }
            }
        }

        #endregion


        return op.Succcedded();
    }

    /// <summary>
    /// دریافت جمع کل خدمات برای یک کارگاه
    /// </summary>
    /// <param name="workshop"></param>
    /// <returns></returns>
    public InstitutionPlanViewModel GetInstitutionPlanForWorkshop(WorkshopTempViewModel workshop)
    {
        return _planPercentageRepository.GetInstitutionPlanForWorkshop(workshop);
    }


    /// <summary>
    /// بررسی و پرداخت
    /// اطلاعات کامل مبالغ
    /// </summary>
    /// <param name="contractingPartyTempId"></param>
    /// <returns></returns>
    public async Task<ReviewAndPaymentViewModel> GetTotalPaymentAndWorkshopList(long contractingPartyTempId,
        InstitutionContractDuration duration = InstitutionContractDuration.TwelveMonths,
        string paymentModel = "OneTime", string contractStartType = "currentMonth")
    {
        throw new NotImplementedException();
        // //دریافت کارگاه ها
        // var workshops = await _workshopTempRepository.GetWorkshopTemp(contractingPartyTempId);
        //
        // double totalPayment1MonthDouble = 0;
        //
        // //بدست آوردن جمع کل برای یک ماه
        // foreach (var workshop in workshops)
        // {
        //     totalPayment1MonthDouble += workshop.WorkshopServicesAmount;
        // }
        //
        // if (totalPayment1MonthDouble == 0)
        //     return new ReviewAndPaymentViewModel();
        //
        // var result = new ReviewAndPaymentViewModel();
        //
        // int months = 0;
        // months = (int)duration;
        // //رند کردن مبالغ کارگاه ها
        // var roundAmount = (((Convert.ToInt64(totalPayment1MonthDouble))) / 1000000) * 1000000;
        // double roundAmount2 = roundAmount;
        // //بدست آوردن جمع کل مبالغ کارگاه بر اساس مدت قراداد
        // result.SumOfWorkshopsPaymentDouble = months * roundAmount2;
        // result.SumOfWorkshopsPaymentPaymentStr = result.SumOfWorkshopsPaymentDouble.ToMoney();
        //
        //
        // result.Duration = duration;
        // result.PaymentModel = paymentModel;
        //
        //
        // var tenPercent = result.SumOfWorkshopsPaymentDouble * 10 / 100;
        // //مالیات
        // result.ValueAddedTaxDouble = tenPercent;
        // result.ValueAddedTaxStr = tenPercent.ToMoney();
        // //پرداخت یکجا
        //
        // #region OneTimePaymentResult
        //
        // double discountOneTimePeyment = result.SumOfWorkshopsPaymentDouble - tenPercent;
        //
        //
        // //مبلغ بدون مالیات و با تخفیف
        // result.OneTimeWithoutTaxPaymentDouble = discountOneTimePeyment;
        // result.OneTimeWithoutTaxPaymentStr = discountOneTimePeyment.ToMoney();
        //
        // //مبلغ با مالیات
        // result.OneTimeTotalPaymentDouble = discountOneTimePeyment + tenPercent;
        // result.OneTimeTotalPaymentStr = result.OneTimeTotalPaymentDouble.ToMoney();
        //
        // #endregion
        //
        // //پرداخت ماهیانه
        //
        // #region MonthlyPaymentResult
        //
        // //مبلغ بدون مالیات
        // result.MonthlyWithoutTaxPaymentDouble = result.SumOfWorkshopsPaymentDouble;
        // result.MonthlyWithoutTaxPaymentStr = result.SumOfWorkshopsPaymentDouble.ToMoney();
        //
        // // مبلغ با مالیات
        // result.MonthlyTotalPaymentDouble = result.SumOfWorkshopsPaymentDouble + tenPercent;
        // result.MonthlyTotalPaymentStr = result.MonthlyTotalPaymentDouble.ToMoney();
        // var installmentList = new List<MonthlyInstallment>();
        //
        // var startDate = (DateTime.Now).ToFarsi();
        // result.ContractStartCurrentMonthFa = $"{startDate.Substring(0, 8)}01";
        // result.ContractStartCurrentMonthGr = result.ContractStartCurrentMonthFa.ToGeorgianDateTime();
        // startDate = result.ContractStartCurrentMonthFa;
        //
        // result.ContractStartNextMonthGr = ((startDate.FindeEndOfMonth()).ToGeorgianDateTime()).AddDays(1);
        // result.ContractStartNextMonthFa = result.ContractStartNextMonthGr.ToFarsi();
        //
        // if (contractStartType == "nextMonth")
        //     startDate = result.ContractStartNextMonthFa;
        //
        //
        // var findeEnd = Tools.FindEndOfContract(startDate, ((int)duration).ToString());
        // var contractEndDate = findeEnd.endDateGr;
        // result.ContractEndGr = contractEndDate;
        // result.ContractEndFa = contractEndDate.ToFarsi();
        //
        // if (duration == InstitutionContractDuration.OneMonth)
        // {
        //     installmentList.Add(new MonthlyInstallment()
        //     {
        //         InstallmentAmountStr = result.MonthlyTotalPaymentStr,
        //         InstallmentCounter = "سررسید پرداخت اول",
        //         InstalmentDate = (DateTime.Now).ToFarsi()
        //     });
        //     result.MonthlyInstallments = installmentList;
        // }
        // else
        // {
        //     int instalmentCount = (int)duration;
        //     var instalmentAmount = result.MonthlyTotalPaymentDouble / instalmentCount;
        //     var findEndOfMonth = startDate.FindeEndOfMonth();
        //     for (int i = 1; i <= instalmentCount; i++)
        //     {
        //         if (i == 1)
        //         {
        //             startDate = (DateTime.Now).ToFarsi();
        //         }
        //         else if (i > 1)
        //         {
        //             var currentMonthStart = ((findEndOfMonth.ToGeorgianDateTime()).AddDays(1)).ToFarsi();
        //             startDate = currentMonthStart.FindeEndOfMonth();
        //             findEndOfMonth = startDate;
        //         }
        //
        //         installmentList.Add(new MonthlyInstallment()
        //         {
        //             InstallmentAmountStr = instalmentAmount.ToMoney(),
        //             InstallmentCounter = i switch
        //             {
        //                 1 => "سررسید پرداخت اول",
        //                 2 => "سررسید پرداخت دوم",
        //                 3 => "سررسید پرداخت سوم",
        //                 4 => "سررسید پرداخت چهارم",
        //                 5 => "سررسید پرداخت پنجم",
        //                 6 => "سررسید پرداخت ششم",
        //                 7 => "سررسید پرداخت هفتم",
        //                 8 => "سررسید پرداخت هشتم",
        //                 9 => "سررسید پرداخت نهم",
        //                 10 => "سررسید پرداخت دهم",
        //                 11 => "سررسید پرداخت یازدهم",
        //                 12 => "سررسید پرداخت دوازدهم",
        //                 _ => "سررسید پرداخت دوازدهم",
        //             },
        //             InstalmentDate = startDate
        //         });
        //     }
        // }
        //
        // #endregion
        //
        // result.MonthlyInstallments = installmentList;
        // result.ContractingPartTempId = contractingPartyTempId;
        //
        // return result;
    }


    public async Task<ReviewAndPaymentViewModel> GetTotalPaymentAndWorkshopList(double totalPaymentMonth,
        InstitutionContractDuration duration, bool hasInPersonContract)
    {
        //دریافت کارگاه ها

        double totalPayment1MonthDouble = 0;

        // //بدست آوردن جمع کل برای یک ماه
        // foreach (var workshop in workshops)
        // {
        //     totalPayment1MonthDouble += workshop.WorkshopServicesAmount;
        // }

        totalPayment1MonthDouble = totalPaymentMonth;
        if (totalPayment1MonthDouble == 0)
            return new ReviewAndPaymentViewModel();

        var result = new ReviewAndPaymentViewModel();

        var months = (int)duration;
        //رند کردن مبالغ کارگاه ها
        var roundAmount = (((Convert.ToInt64(totalPayment1MonthDouble))) / 1000000) * 1000000;
        double roundAmount2 = roundAmount;
        //بدست آوردن جمع کل مبالغ کارگاه بر اساس مدت قراداد
        var sumOfWorkshopsPaymentDouble = months * roundAmount2;
        result.SumOfWorkshopsPayment = roundAmount2.ToMoney();
        var installmentstart = (DateTime.Now).ToFarsi();

        var originalDay = int.Parse(installmentstart.Substring(8, 2));
        result.ContractStartFa = installmentstart;
        result.ContractStartGr = result.ContractStartFa.ToGeorgianDateTime();

        var findeEnd = Tools.FindEndOfContract(installmentstart, ((int)duration).ToString());
        var contractEndDate = findeEnd.endDateGr;
        result.ContractEndGr = contractEndDate;
        result.ContractEndFa = contractEndDate.ToFarsi();

        if (hasInPersonContract)
        {
            var tenPercent = sumOfWorkshopsPaymentDouble * 10 / 100;
            //مالیات
            result.ValueAddedTaxStr = tenPercent.ToMoney();
            //پرداخت یکجا

            #region OneTimePaymentResult

            double discountOneTimePeyment = sumOfWorkshopsPaymentDouble - tenPercent;

            result.Discount = tenPercent.ToMoney();
            
            //مبلغ بدون مالیات و با تخفیف
            result.OneTimeWithoutTaxPaymentStr = discountOneTimePeyment.ToMoney();

            //مبلغ با مالیات
            var oneTimePayment = discountOneTimePeyment + tenPercent;
            result.OneTimeTotalPaymentStr = oneTimePayment.ToMoney();

            #endregion


            //پرداخت ماهیانه

            #region MonthlyPaymentResult

            //مبلغ بدون مالیات
   
            result.MonthlyWithoutTaxPaymentStr = sumOfWorkshopsPaymentDouble.ToMoney();

            // مبلغ با مالیات
            var monthlyTotalPaymentDouble = sumOfWorkshopsPaymentDouble + tenPercent;
            result.MonthlyTotalPaymentStr = monthlyTotalPaymentDouble.ToMoney();
            var installmentList = new List<MonthlyInstallment>();

           
            int instalmentCount = (int)duration;
            var instalmentAmount = monthlyTotalPaymentDouble / instalmentCount;
            int currentInstallmentStartDay = int.Parse(installmentstart.Substring(8, 2));
            bool endOfMonth = currentInstallmentStartDay == 31;

            // Loop through each installment period
            for (int i = 1; i <= instalmentCount; i++)
            {
                string installmentDate;
                // For first installment, use the initial date
                if (i == 1)
                {
                    installmentDate = installmentstart;
                }
                else
                {
                    var currentDay = int.Parse(installmentstart.Substring(8, 2));
                    var currentMonth = int.Parse(installmentstart.Substring(5, 2));
                    var currentYear = int.Parse(installmentstart.Substring(0, 4));
        
                    // Get next month's date
                    var nextMonthFa = installmentstart.ToGeorgianDateTime().AddMonthsFa(1, out var nextMonth);
                    var maxDayInNextMonth = int.Parse(nextMonthFa.FindeEndOfMonth().Substring(8, 2));
        
                    // Use original day if possible, otherwise use last day of month
                    var dayToUse = Math.Min(originalDay, maxDayInNextMonth);
                    installmentDate = nextMonthFa.Substring(0, 8) + dayToUse.ToString("D2");
        
                    // Update installmentstart for next iteration
                    installmentstart = installmentDate;
                }

                installmentList.Add(new MonthlyInstallment()
                {
                    InstallmentAmountStr = instalmentAmount.ToMoney(),
                    InstallmentCounter = i switch
                    {
                        1 => "سررسید پرداخت اول",
                        2 => "سررسید پرداخت دوم",
                        3 => "سررسید پرداخت سوم",
                        4 => "سررسید پرداخت چهارم",
                        5 => "سررسید پرداخت پنجم",
                        6 => "سررسید پرداخت ششم",
                        7 => "سررسید پرداخت هفتم",
                        8 => "سررسید پرداخت هشتم",
                        9 => "سررسید پرداخت نهم",
                        10 => "سررسید پرداخت دهم",
                        11 => "سررسید پرداخت یازدهم",
                        12 => "سررسید پرداخت دوازدهم",
                        _ => "سررسید پرداخت دوازدهم",
                    },
                    InstalmentDate = installmentDate
                });
            }
            #endregion

            result.MonthlyInstallments = installmentList;
        }
        else
        {
            var discount = duration switch
            {
                InstitutionContractDuration.OneMonth => 0,
                InstitutionContractDuration.ThreeMonths => 5,
                InstitutionContractDuration.SixMonths => 10,
                InstitutionContractDuration.TwelveMonths => 15,
                _ => throw new ArgumentOutOfRangeException(nameof(duration), duration, null)
            };
            
            var oneMonthDiscountAmount = (roundAmount2 * discount) / 100;
            var totalDiscount = oneMonthDiscountAmount * months;
            var discountedPayment = sumOfWorkshopsPaymentDouble - totalDiscount;
            result.Discount = oneMonthDiscountAmount.ToMoney();
            result.DiscountedAmountForOneMonth = (roundAmount2 - oneMonthDiscountAmount).ToMoney();
            var taxDouble = (discountedPayment * 10)/100;
            result.ValueAddedTaxStr =taxDouble.ToMoney();
            result.OneTimeWithoutTaxPaymentStr = discountedPayment.ToMoney();
            result.OneTimeTotalPaymentStr =( discountedPayment + taxDouble).ToMoney();
        }

        result.DailyCompensation = ((roundAmount2 * 10) / 100).ToMoney();
        result.Obligation = result.OneTimeTotalPaymentStr;
        return result;
    }

    /// <summary>
    /// ایجاد یا ویرایش قرارداد موقت
    /// </summary>
    /// <param name="contractingPartyTempId"></param>
    /// <returns></returns>
    public async Task<OperationResult> CreateOrUpdateInstitutionContractTemp(long contractingPartyTempId,
        string periodModel, string paymentModel, double totalPayment, double valueAddedTax, DateTime contractStart)
    {
        var op = new OperationResult();


        var institutionContractTemp = await
            _institutionContractTempRepository.GetInstitutionContractTemp(0, contractingPartyTempId);
        var contractStartDate = contractStart;
        string contractStartFa = contractStart.ToFarsi();
        var findeEnd = Tools.FindEndOfContract(contractStartFa, periodModel);
        var contractEndDate = findeEnd.endDateGr;
        if (institutionContractTemp == null)
        {
            var periodModelInt = Convert.ToInt32(periodModel);

            var create = new InstitutionContractTemp(contractingPartyTempId, paymentModel, periodModel, totalPayment,
                contractStartDate, contractEndDate, "official", valueAddedTax, "",
                InstitutionContractTempStatus.BeforeSendVerifyCode, 0, null,
                null);
            _institutionContractTempRepository.Create(create);
            _institutionContractTempRepository.SaveChanges();

            //temporary
            var res = await PayOffCompleted(contractingPartyTempId);
            if (!res.IsSuccedded)
                return op.Failed(res.Message);
            return op.Succcedded();
        }
        else
        {
            if (institutionContractTemp.VerifyCodeEndTime != null)
            {
                var spaning = (DateTime.Now - institutionContractTemp.VerifyCodeEndTime.Value);
                if (institutionContractTemp.RegistrationStatus == InstitutionContractTempStatus.VerifyCodeSent &&
                    spaning > new TimeSpan(0, 0, 0) &&
                    spaning < new TimeSpan(0, 1, 0))
                    return op.Failed("شما به تازگی پیامک دریافت نموده اید دو دقیقه صبر کنید و دوباره تلاش کنید");
            }

            if (institutionContractTemp.RegistrationStatus == InstitutionContractTempStatus.Completed)
                return op.Failed("شما قبلا ثبت نام خود را تکمیل نموده اید");


            var periodModelInt = Convert.ToInt32(periodModel);
            var contractstart = DateTime.Now;
            var contractEnd = DateTime.Now.AddMonths(periodModelInt);
            var update = _institutionContractTempRepository.Get(institutionContractTemp.Id);
            update.Edit(contractingPartyTempId, paymentModel, periodModel, totalPayment, contractStartDate,
                contractEndDate, "official", valueAddedTax, "", InstitutionContractTempStatus.BeforeSendVerifyCode, 0,
                null, null);
            _institutionContractTempRepository.SaveChanges();

            //temporary
            var res = await PayOffCompleted(contractingPartyTempId);
            if (!res.IsSuccedded)
                return op.Failed(res.Message);
            return op.Succcedded();
        }
    }


    /// <summary>
    /// دریافت کد برای کلاینت
    /// از طرف سرور
    /// </summary>
    /// <param name="contractingPartyTempId"></param>
    /// <returns></returns>
    public async Task<OperationResult> ReceivedCodeFromServer(long contractingPartyTempId)
    {
        var op = new OperationResult();


        var institutionContractTemp = await
            _institutionContractTempRepository.GetInstitutionContractTemp(0, contractingPartyTempId);
        if (institutionContractTemp == null)
            return op.Failed("خطا");

        var update = _institutionContractTempRepository.Get(institutionContractTemp.Id);


        if (institutionContractTemp.RegistrationStatus == InstitutionContractTempStatus.BeforeSendVerifyCode)
        {
            //ساخت کد شش رقمی
            Random generator = new Random();
            String code = generator.Next(1, 1000000).ToString("D6");
            //ارسال اس ام اس
            var getContractingPaty =
                _contractingPartyTempRepository.GetByContractingPartyTempId(contractingPartyTempId);
            var sendResult = await _smsService.SendVerifyCodeToClient(getContractingPaty.Phone, code);

            if (!sendResult.IsSuccedded)
                return op.Failed($"{sendResult.Message}");

            //ذخیره کد در دیتا بیس
            //ذخیره تاریخ ارسال و مهلت پایان
            //ذخیره آیدی پیامک
            //تغییر وضعیت به ارسال شده
            if (update != null)
            {
                update.Update(code, InstitutionContractTempStatus.VerifyCodeSent, sendResult.MessageId, DateTime.Now,
                    DateTime.Now.AddMinutes(2));
                _institutionContractTempRepository.SaveChanges();
                return op.Succcedded(1, "کد برای شما پیامک شد");
            }
        }

        if (institutionContractTemp.RegistrationStatus == InstitutionContractTempStatus.VerifyCodeSent)

        {
            if (DateTime.Now < institutionContractTemp.VerifyCodeEndTime.Value)
                return op.Failed("کد دریافت شده را وارد کنید");
            var spaning = (DateTime.Now - institutionContractTemp.VerifyCodeEndTime.Value);
            if ((spaning > new TimeSpan(0, 0, 0) && spaning < new TimeSpan(0, 1, 0)))
                return op.Failed("شما به تازگی پیامک دریافت نموده اید دو دقیقه صبر کنید و دوباره تلاش کنید");

            if ((spaning > new TimeSpan(0, 1, 0)))
            {
                //ساخت کد شش رقمی
                Random generator = new Random();
                String code = generator.Next(1, 1000000).ToString("D6");
                //ارسال اس ام اس
                var getContractingPaty =
                    _contractingPartyTempRepository.GetByContractingPartyTempId(contractingPartyTempId);
                var sendResult = await _smsService.SendVerifyCodeToClient(getContractingPaty.Phone, code);

                if (!sendResult.IsSuccedded)
                    return op.Failed($"{sendResult.Message}");


                //ذخیره کد در دیتا بیس
                //ذخیره تاریخ ارسال و مهلت پایان
                //ذخیره آیدی پیامک
                //تغییر وضعیت به ارسال شده

                if (update != null)
                {
                    update.Update(code, InstitutionContractTempStatus.VerifyCodeSent, sendResult.MessageId,
                        DateTime.Now,
                        DateTime.Now.AddMinutes(2));
                    _institutionContractTempRepository.SaveChanges();
                    return op.Succcedded(1, "کد برای شما پیامک شد");
                }
            }
        }

        //if (institutionContractTemp.RegistrationStatus == "ReceivedCodeFromClient")
        //    return op.Succcedded(2, "انتقال به بخش پرداخت");

        if (institutionContractTemp.RegistrationStatus == InstitutionContractTempStatus.Completed)
            return op.Failed("شما قبلا ثبت نام خود را تکمیل نموده اید");
        return op.Failed("خظا");
    }

    /// <summary>
    /// ورود کد از طرف کلاینت
    /// برا چک کردن
    /// </summary>
    /// <param name="contractingPartyTempId"></param>
    /// <param name="verifyCode"></param>
    /// <returns></returns>
    public async Task<OperationResult> CheckVerifyCodeIsTrue(long contractingPartyTempId, string verifyCode)
    {
        var op = new OperationResult();
        var institutionContractTemp = await
            _institutionContractTempRepository.GetInstitutionContractTemp(0, contractingPartyTempId);
        if (institutionContractTemp == null)
            return op.Failed("خظا");

        if (institutionContractTemp.RegistrationStatus != InstitutionContractTempStatus.VerifyCodeSent)
            return op.Failed("خطا");

        if (institutionContractTemp.VerifyCodeEndTime < DateTime.Now)
            return op.Failed("کد شما منقضی شده است");

        if (institutionContractTemp.SendVerifyCodeTime < DateTime.Now &&
            institutionContractTemp.VerifyCodeEndTime >= DateTime.Now)
        {
            if (institutionContractTemp.VerifyCode == verifyCode)
            {
                return op.Succcedded();
            }
            else
            {
                return op.Failed("کد وارد شده صحیح نیست");
            }
        }


        return op.Failed("کد وارد شده صحیح نیست");
    }


    /// <summary>
    /// تکمیل پرداخت
    /// </summary>
    /// <param name="contractingPartyTempId"></param>
    /// <param name="verifyCode"></param>
    /// <returns></returns>
    public async Task<OperationResult> PayOffCompleted(long contractingPartyTempId)
    {
        var op = new OperationResult();

        var temp = _contractingPartyTempRepository.GetByContractingPartyTempId(contractingPartyTempId);
        if (_personalContractingPartyRepository.Exists(x =>
                x.Nationalcode == temp.NationalCode))
            return op.Failed("امکان ثبت رکورد تکراری وجود ندارد");

        var lastArchiveCode = _personalContractingPartyRepository.GetLastNewArchiveCode();
        var personalContractingParty = new PersonalContractingParty(temp.FName, temp.LName,
            temp.NationalCode, temp.IdNumber, "*", "*",
            "حقیقی",
            temp.Phone, null, temp.Address, 1, "-", lastArchiveCode,
            temp.State, temp.City, null, null);
        _personalContractingPartyRepository.Create(personalContractingParty);
        _personalContractingPartyRepository.SaveChanges();

        personalContractingParty.RegisterComplete(temp.FatherName, temp.IdNumberSeri, temp.IdNumberSerial,
            temp.DateOfBirth, temp.Gender);
        _personalContractingPartyRepository.SaveChanges();
        var institutionContractTemp = await
            _institutionContractTempRepository.GetInstitutionContractTemp(0, contractingPartyTempId);
        var update = _institutionContractTempRepository.Get(institutionContractTemp.Id);
        update.ChangeRegistrationStatus(InstitutionContractTempStatus.PendingToCompletion);
        _institutionContractTempRepository.SaveChanges();


        return op.Succcedded();
    }


    public async Task<OperationResult> SendAgreementLink(long contractingPartyTempId)
    {
        var op = new OperationResult();
        var institutionContractTemp = _institutionContractTempRepository.Get(contractingPartyTempId);
        if (institutionContractTemp == null)
            throw new NotFoundException("طرف حساب یافت نشد");

        if (institutionContractTemp.RegistrationStatus == InstitutionContractTempStatus.Completed)
            throw new BadRequestException("شما قبلا ثبت نام خود را تکمیل نموده اید");

        //ارسال لینک به طرف حساب
        //Todo: implement the logic to send the agreement link to the contracting party


        return op.Succcedded();
    }
}