using General_Ledger_Service.Enums;
using General_Ledger_Service.Infra;
using General_Ledger_Service.Interfaces.Repositories;
using General_Ledger_Service.Models;
using Microsoft.EntityFrameworkCore;

namespace General_Ledger_Service.Repositories
{
    public class ChequeRepository(AppDBContext context) : IChequeRepository
    {
        private readonly AppDBContext _context = context;

        public Task<ChequeBook> AddChequeBookAsync(ChequeBook chequeBook) =>
            RepositoryHelpers.AddAsync(_context.ChequeBooks, chequeBook);

        public Task<ChequeBook?> GetChequeBookByIdAsync(long chequeBookId) =>
            RepositoryHelpers.GetByIdAsync(_context.ChequeBooks, chequeBookId);

        public async Task<ChequeBook?> GetChequeBookByNoAsync(string chequeBookNo, bool includePages = false)
        {
            var query = _context.ChequeBooks.AsQueryable();
            if (includePages)
            {
                query = query.Include(b => b.Pages);
            }

            return await query.FirstOrDefaultAsync(b => b.ChequeBookNo == chequeBookNo);
        }

        public Task<bool> ChequeBookNoExistsAsync(string chequeBookNo) =>
            RepositoryHelpers.ExistsAsync(_context.ChequeBooks, b => b.ChequeBookNo == chequeBookNo);

        public async Task<(List<ChequeBook> Items, int TotalCount)> ListChequeBooksAsync(
            long? bankAccountId, long? branchId, ChequeBookStatus? status, int? page, int? pageSize)
        {
            var query = _context.ChequeBooks.AsQueryable();

            if (bankAccountId.HasValue) query = query.Where(b => b.BankAccountId == bankAccountId.Value);
            if (branchId.HasValue) query = query.Where(b => b.BranchId == branchId.Value);
            if (status.HasValue) query = query.Where(b => b.Status == status.Value);

            query = query.OrderByDescending(b => b.ReceivedDate).ThenBy(b => b.ChequeBookNo);

            var totalCount = await query.CountAsync();
            var items = await RepositoryHelpers.ApplyPaging(query, page, pageSize).ToListAsync();

            return (items, totalCount);
        }

        public async Task AddChequePagesAsync(IEnumerable<ChequePage> pages) =>
            await _context.ChequePages.AddRangeAsync(pages);

        public async Task<ChequePage?> GetChequePageByNoAsync(string chequeNo) =>
            await _context.ChequePages.Include(p => p.ChequeBook).FirstOrDefaultAsync(p => p.ChequeNo == chequeNo);

        public Task<bool> ChequeNoExistsAsync(string chequeNo) =>
            RepositoryHelpers.ExistsAsync(_context.ChequePages, p => p.ChequeNo == chequeNo);

        public async Task<(List<ChequePage> Items, int TotalCount)> ListChequePagesAsync(
            string? chequeBookNo, ChequeIssueStatus? issueStatus, ChequePayeeType? payeeType,
            long? payeeId, int? page, int? pageSize)
        {
            var query = _context.ChequePages.Include(p => p.ChequeBook).AsQueryable();

            if (!string.IsNullOrWhiteSpace(chequeBookNo)) query = query.Where(p => p.ChequeBook.ChequeBookNo == chequeBookNo);
            if (issueStatus.HasValue) query = query.Where(p => p.IssueStatus == issueStatus.Value);
            if (payeeType.HasValue) query = query.Where(p => p.PayeeType == payeeType.Value);
            if (payeeId.HasValue) query = query.Where(p => p.PayeeId == payeeId.Value);

            query = query.OrderBy(p => p.ChequeNo);

            var totalCount = await query.CountAsync();
            var items = await RepositoryHelpers.ApplyPaging(query, page, pageSize).ToListAsync();

            return (items, totalCount);
        }

        public Task<ReceivedCheque> AddReceivedChequeAsync(ReceivedCheque receivedCheque) =>
            RepositoryHelpers.AddAsync(_context.ReceivedCheques, receivedCheque);

        public Task<ReceivedCheque?> GetReceivedChequeByIdAsync(long receivedChequeId) =>
            RepositoryHelpers.GetByIdAsync(_context.ReceivedCheques, receivedChequeId);

        public async Task<(List<ReceivedCheque> Items, int TotalCount)> ListReceivedChequesAsync(
            long? companyId, long? branchId, ReceivedChequeStatus? status,
            ReceivedChequeFromType? receivedFromType, int? page, int? pageSize)
        {
            var query = _context.ReceivedCheques.AsQueryable();

            if (companyId.HasValue) query = query.Where(c => c.CompanyId == companyId.Value);
            if (branchId.HasValue) query = query.Where(c => c.BranchId == branchId.Value);
            if (status.HasValue) query = query.Where(c => c.Status == status.Value);
            if (receivedFromType.HasValue) query = query.Where(c => c.ReceivedFromType == receivedFromType.Value);

            query = query.OrderByDescending(c => c.ReceivedDate).ThenByDescending(c => c.ReceivedChequeId);

            var totalCount = await query.CountAsync();
            var items = await RepositoryHelpers.ApplyPaging(query, page, pageSize).ToListAsync();

            return (items, totalCount);
        }
    }
}