using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using _0_Framework.Application;
using _0_Framework.InfraStructure;
using Company.Domain.FinancialInvoiceAgg;
using CompanyManagment.App.Contracts.FinancialInvoice;
using Microsoft.EntityFrameworkCore;

namespace CompanyManagment.EFCore.Repository;

public class FinancialInvoiceRepository : RepositoryBase<long, FinancialInvoice>, IFinancialInvoiceRepository
{
    private readonly CompanyContext _context;

    public FinancialInvoiceRepository(CompanyContext context) : base(context)
    {
        _context = context;
    }

    public EditFinancialInvoice GetDetails(long id)
    {
        var financialInvoice = _context.FinancialInvoices
            .Include(x => x.Items)
            .FirstOrDefault(x => x.id == id);

        if (financialInvoice == null)
            return null;

        return new EditFinancialInvoice
        {
            Id = financialInvoice.id,
            Description = financialInvoice.Description,
            Amount = financialInvoice.Amount,
            Status =  financialInvoice.Status,
            InvoiceNumber = financialInvoice.InvoiceNumber,
            Items = financialInvoice.Items?.Select(x => new EditFinancialInvoiceItem
            {
                Id = x.id,
                Description = x.Description,
                Amount = x.Amount,
                Type = x.Type,
                EntityId = x.EntityId
            }).ToList()
        };
    }

    public List<FinancialInvoiceViewModel> Search(FinancialInvoiceSearchModel searchModel)
    {
        var query = _context.FinancialInvoices
            .Include(x => x.Items)
            .AsQueryable();

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

        if (searchModel.Status.HasValue)
            query = query.Where(x => x.Status == searchModel.Status.Value);

        if (searchModel.ContractingPartyId.HasValue)
            query = query.Where(x => x.ContractingPartyId == searchModel.ContractingPartyId.Value);

        if (!string.IsNullOrWhiteSpace(searchModel.FromDate))
        {
            var fromDate = searchModel.FromDate.ToGeorgianDateTime();
            query = query.Where(x => x.CreationDate >= fromDate);
        }

        if (!string.IsNullOrWhiteSpace(searchModel.ToDate))
        {
            var toDate = searchModel.ToDate.ToGeorgianDateTime();
            query = query.Where(x => x.CreationDate <= toDate);
        }

        if (searchModel.MinAmount.HasValue)
            query = query.Where(x => x.Amount >= searchModel.MinAmount.Value);

        if (searchModel.MaxAmount.HasValue)
            query = query.Where(x => x.Amount <= searchModel.MaxAmount.Value);

        return query.OrderByDescending(x => x.id)
            .Select(x => new FinancialInvoiceViewModel
            {
                Id = x.id,
                Description = x.Description,
                Status = x.Status.ToString(),
                PaidAt = x.PaidAt.HasValue ? x.PaidAt.Value.ToFarsi() : "",
                Amount = x.Amount,
                PublicId = x.PublicId,
                ContractingPartyId = x.ContractingPartyId,
                CreationDate = x.CreationDate.ToFarsi(),
                ItemsCount = x.Items != null ? x.Items.Count : 0
            }).ToList();
    }

    public async Task<FinancialInvoice> GetUnPaidByEntityId(long entityId,
        FinancialInvoiceItemType financialInvoiceItemType)
    {
       return await _context.FinancialInvoices.Include(x => x.Items)
            .Where(x => x.Status == FinancialInvoiceStatus.Unpaid).FirstOrDefaultAsync(x => x.Items
                .Any(y => y.Type == financialInvoiceItemType && y.EntityId == entityId));
    }
}