using System;
using _0_Framework.InfraStructure;
using Company.Domain.LoanAgg;
using Company.Domain.LoanAgg.Entities;
using CompanyManagment.App.Contracts.Loan;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using _0_Framework.Application;
using Microsoft.EntityFrameworkCore;
using System.Globalization;
using System.Collections;

namespace CompanyManagment.EFCore.Repository;

public class LoanRepository : RepositoryBase<long, Loan>, ILoanRepository
{
    private readonly CompanyContext _companyContext;

    public LoanRepository(CompanyContext companyContext) : base(companyContext)
    {
        _companyContext = companyContext;
    }

    public async Task<LoanDetailsViewModel> GetDetails(long id)
    {
        var loan = await _companyContext.Loans.FirstOrDefaultAsync(x => x.id == id);
        if (loan == null)
        {
            return null;
        }

        var employeeName = await _companyContext.Employees.Where(x => x.id == loan.EmployeeId)
            .Select(x => x.FName + " " + x.LName).FirstOrDefaultAsync();

        var startDate = loan.LoanInstallments.MinBy(x => x.InstallmentDate).InstallmentDate;
        var endDate = loan.LoanInstallments.MaxBy(x => x.InstallmentDate).InstallmentDate;
        var pc = new PersianCalendar();
        var checkouts = (await _companyContext.CheckoutSet
            .Where(x => x.WorkshopId == loan.WorkshopId && x.EmployeeId == loan.EmployeeId &&
                        startDate <= x.ContractEnd && endDate >= x.ContractEnd).AsNoTracking()
            .SelectMany(x => x.LoanInstallments).ToListAsync());

        var result = new LoanDetailsViewModel()
        {
            TotalLoanAmount = loan.Amount.ToMoney(),
            InstallmentCount = loan.LoanInstallments.Count.ToString(),
            EmployeeFullName = employeeName,
            Id = loan.id,
            LoanGrantDate = loan.LoanGrantDate.ToFarsi(),
            Installments = loan.LoanInstallments.Select(x => new LoanInstallmentDetailsViewModel()
            {
                Id = x.Id,
                InstallmentAmount = x.AmountForMonth.ToMoney(),
                InstallmentDate = x.InstallmentDate.ToFarsi(),
                IsPaid = checkouts.Any(c => c.EntityId == x.Id),
            }).ToList()

        };
        var totalPaidAmountD = result.Installments.Where(x => x.IsPaid).Sum(x => x.InstallmentAmount.MoneyToDouble());
        var remainingD = result.Installments.Where(x => !x.IsPaid).Sum(x => x.InstallmentAmount.MoneyToDouble());
        result.TotalPaidAmount = totalPaidAmountD.ToMoney();
        result.TotalRemainingAmount= remainingD.ToMoney();

        return result;

    }

    public List<Loan> GetBy(IEnumerable<long> ids)
    {
        return _companyContext.Loans.Where(x => ids.Contains(x.id)).ToList();
    }

    public LoanGroupedViewModel GetSearchListAsGrouped(LoanSearchViewModel searchModel)
    {
        var result = new LoanGroupedViewModel();

        var query = _companyContext.Loans.Where(x => x.WorkshopId == searchModel.WorkshopId);

        var personnelCodes = _companyContext.PersonnelCodeSet
            .Where(x => x.WorkshopId == searchModel.WorkshopId).ToList();

        var employees = _companyContext.LeftWorkList.Where(x => x.WorkshopId == searchModel.WorkshopId)
            .Include(x => x.Employee).Select(x => x.Employee).ToList();

        var pc = new PersianCalendar();

        if (searchModel.ShowAsGrouped)
        {
            if (searchModel.EmployeeId > 0)
            {
                if (!string.IsNullOrWhiteSpace(searchModel.StartDate) &&
                    !string.IsNullOrWhiteSpace(searchModel.EndDate))
                {
                    var startDate = searchModel.StartDate.ToGeorgianDateTime();
                    var endDate = searchModel.EndDate.ToGeorgianDateTime();
                    query = query.Where(x => x.StartInstallmentPayment >= startDate && x.StartInstallmentPayment <= endDate);
                }
                query = query.Where(x => x.EmployeeId == searchModel.EmployeeId);
                var list = query.OrderByDescending(x=>x.StartInstallmentPayment).ToList().Select(x => new LoanViewModel()
                {
                    Amount = x.Amount.ToMoney(),
                    AmountDouble = x.Amount,
                    EmployeeFullName = employees.FirstOrDefault(e => e.id == x.EmployeeId).FullName,
                    EmployeeId = x.EmployeeId,
                    CreationDate = x.CreationDate,
                    Id = x.id,
                    MonthFa = pc.GetMonth(x.StartInstallmentPayment).ToFarsiMonthByIntNumber(),
                    YearFa = pc.GetYear(x.StartInstallmentPayment).ToString(),
                    PersonnelCode = personnelCodes.FirstOrDefault(p => p.EmployeeId == x.EmployeeId).PersonnelCode.ToString(),
                    StartDateTime = x.StartInstallmentPayment.ToFarsi(),
                    Count = x.Count,
                    AmountPerMonth = x.AmountPerMonth.ToMoney(),
                    WorkshopId = x.WorkshopId,
                }).ToList();
                result.GroupedByDate = list.GroupBy(x => new { x.YearFa, x.MonthFa }).Select(x =>
                    new LoanGroupedByDateViewModel()
                    {
                        MonthFa = x.Key.MonthFa,
                        YearFa = x.Key.YearFa,
                        TotalAmount = x.Sum(l => l.AmountDouble).ToMoney(),
                        LoanItems = x.Select(l => new LoanGroupedByDateViewModelItems()
                        {
                            AmountPerMonth = l.AmountPerMonth,
                            EmployeeName = l.EmployeeFullName,
                            Id = l.Id,
                            InstallmentCount = l.Count,
                            LoanStartDate = l.StartDateTime,
                            PersonnelCode = l.PersonnelCode,
                            TotalAmountFa = l.Amount
                        }).ToList()
                    }).ToList();
                return result;


            }
            else if (!string.IsNullOrWhiteSpace(searchModel.StartDate) &&
                     !string.IsNullOrWhiteSpace(searchModel.EndDate))
            {
                var startDate = searchModel.StartDate.ToGeorgianDateTime();

                var endDate = searchModel.EndDate.ToGeorgianDateTime();

                query = query.Where(x => x.StartInstallmentPayment >= startDate && x.StartInstallmentPayment <= endDate);
                result.GroupedByEmployee = query.GroupBy(x => x.EmployeeId).ToList()
                    .Select(x => new LoanGroupedByEmployeeViewModel()
                    {
                        EmployeeName = employees.FirstOrDefault(e => e.id == x.Key).FullName,
                        LoanItems = x.Select(l => new LoanGroupedByEmployeeViewModelItems()
                        {
                            TotalAmountFa = l.Amount.ToMoney(),
                            AmountPerMonth = l.AmountPerMonth.ToMoney(),
                            Id = l.id,
                            InstallmentCount = l.Count,
                            LoanDateTimeFa = l.StartInstallmentPayment.ToFarsi(),
                            PersonnelCode = personnelCodes.FirstOrDefault(p => p.EmployeeId == l.EmployeeId).PersonnelCode.ToString(),

                        }).ToList(),
                        TotalAmount = x.Sum(l => l.Amount).ToMoney()
                    }).ToList();
                return result;
            }
        }

        if (searchModel.EmployeeId > 0)
            query = query.Where(x => x.EmployeeId == searchModel.EmployeeId);
        if (!string.IsNullOrWhiteSpace(searchModel.StartDate) && !string.IsNullOrWhiteSpace(searchModel.EndDate))
        {
            var startDate = searchModel.StartDate.ToGeorgianDateTime();
            var endDate = searchModel.EndDate.ToGeorgianDateTime();
            query = query.Where(x => x.StartInstallmentPayment >= startDate && x.StartInstallmentPayment <= endDate);
        }

        result.LoanListViewModel = new PagedResult<LoanViewModel>()
        {
            TotalCount = query.Count(),
            List = query.OrderByDescending(x => x.StartInstallmentPayment)
                .ApplyPagination(searchModel.PageIndex, searchModel.PageSize)
                .Take(30).ToList()
                .Select(x => new LoanViewModel()
                {
                    EmployeeFullName = employees.FirstOrDefault(e => e.id == x.EmployeeId).FullName,
                    PersonnelCode = personnelCodes.FirstOrDefault(p => p.EmployeeId == x.EmployeeId).PersonnelCode
                        .ToString(),
                    Amount = x.Amount.ToMoney(),
                    AmountPerMonth = x.AmountPerMonth.ToMoney(),
                    StartDateTime = x.StartInstallmentPayment.ToFarsi(),
                    Count = x.Count,
                    Id = x.id,
                    WorkshopId = x.WorkshopId,
                    EmployeeId = x.EmployeeId,
                    YearFa = pc.GetYear(x.StartInstallmentPayment).ToString(),

                }).ToList()
        };

        return result;
    }

    public List<LoanViewModel> GetSearchList(LoanSearchViewModel searchViewModel)
    {
        var query = _companyContext.Loans.Where(x => x.WorkshopId == searchViewModel.WorkshopId);

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

        if (!string.IsNullOrWhiteSpace(searchViewModel.StartDate) && !string.IsNullOrWhiteSpace(searchViewModel.EndDate))
        {
            var startDate = searchViewModel.StartDate.ToGeorgianDateTime();
            var endDate = searchViewModel.EndDate.ToGeorgianDateTime();

            query = query.Where(x => x.LoanGrantDate <= endDate && x.LoanGrantDate >= startDate);
        }


        var employeeIds = query.Select(x => x.EmployeeId);

        var personnelCodes = _companyContext.PersonnelCodeSet.Where(x => x.WorkshopId == searchViewModel.WorkshopId && employeeIds.Contains(x.EmployeeId));


        var employees = _companyContext.Employees.Where(x => employeeIds.Contains(x.id)).AsSplitQuery();

        return query.Select(x => new LoanViewModel()
        {
            Id = x.id,
            WorkshopId = x.WorkshopId,
            EmployeeId = x.EmployeeId,
            EmployeeFullName = employees.FirstOrDefault(e => e.id == x.EmployeeId).FullName,
            PersonnelCode = personnelCodes.FirstOrDefault(e => e.EmployeeId == x.EmployeeId && e.WorkshopId == searchViewModel.WorkshopId).PersonnelCode.ToString(),
            StartDateTime = x.StartInstallmentPayment.ToFarsi(),
            Count = x.Count,
            Amount = x.Amount.ToMoney(),
            AmountPerMonth = x.AmountPerMonth.ToMoney(),
            CreationDate = x.CreationDate
        }).OrderByDescending(x => x.CreationDate).Skip(searchViewModel.PageIndex).AsSplitQuery().Take(30).ToList();
    }
}