using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using PowderCoating.Application.DTOs.Accounting;
using PowderCoating.Application.Interfaces;
using PowderCoating.Core.Enums;
using PowderCoating.Infrastructure.Data;

namespace PowderCoating.Infrastructure.Services;

/// <summary>
/// Builds chronological ledger reports for individual accounts by querying every transaction
/// table that can touch a given account (Payments, Expenses, BillPayments, InvoiceItems, Bills,
/// AR, AP) and computing a running balance. Also drives <see cref="AccountBalanceService.RecalculateAllAsync"/>
/// by returning the authoritative closing balance.
/// </summary>
public class LedgerService : ILedgerService
{
    private readonly ApplicationDbContext _context;
    private readonly ILogger<LedgerService> _logger;

    /// <summary>
    /// Constructs the service with direct <see cref="ApplicationDbContext"/> access.
    /// Direct context access (rather than repositories) is intentional here: the ledger
    /// must query multiple tables with heterogeneous filters and EF navigation properties,
    /// which would require many separate repository calls that would be slower and less readable.
    /// </summary>
    public LedgerService(ApplicationDbContext context, ILogger<LedgerService> logger)
    {
        _context = context;
        _logger = logger;
    }

    /// <summary>
    /// Assembles a full ledger report for an account over the given date range, including
    /// nine distinct transaction sources: customer payments deposited, expenses paid from,
    /// bill payments paid from, invoice revenue line items, sales tax, direct expense
    /// categorizations, bill line-item categorizations, AR movements, and AP movements.
    /// Returns <c>null</c> when the account does not exist or is filtered out by the global
    /// query filters (company isolation / soft delete).
    /// The <c>OpeningBalance</c> in the returned DTO represents the account balance on the day
    /// before <paramref name="from"/>, computed by <see cref="ComputePriorBalanceAsync"/>.
    /// </summary>
    public async Task<AccountLedgerDto?> GetAccountLedgerAsync(int accountId, DateTime from, DateTime to)
    {
        // Use FirstOrDefaultAsync so global query filters (company isolation, soft delete) apply
        var account = await _context.Accounts.FirstOrDefaultAsync(a => a.Id == accountId);
        if (account == null) return null;

        var fromDate = from.Date;
        var toDate = to.Date.AddDays(1).AddTicks(-1); // inclusive end of day

        var entries = new List<LedgerEntryDto>();

        // ── 1. Customer payments deposited INTO this account (DEBIT) ──────────
        // e.g. Checking/Savings account receives a customer payment
        var depositedPayments = await _context.Payments
            .Include(p => p.Invoice)
            .Where(p => p.DepositAccountId == accountId
                     && p.PaymentDate >= fromDate && p.PaymentDate <= toDate)
            .ToListAsync();

        foreach (var p in depositedPayments)
            entries.Add(new LedgerEntryDto
            {
                Date = p.PaymentDate,
                Reference = p.Invoice?.InvoiceNumber ?? $"PMT-{p.Id}",
                Source = "Customer Payment",
                Description = p.Notes ?? p.Reference,
                Debit = p.Amount,
                Credit = 0,
                LinkController = "Invoices",
                LinkId = p.InvoiceId
            });

        // ── 2. Direct expenses paid FROM this account (CREDIT) ────────────────
        // e.g. Checking account used to pay an expense
        var expensesPaidFrom = await _context.Expenses
            .Include(e => e.Vendor)
            .Where(e => e.PaymentAccountId == accountId
                     && e.Date >= fromDate && e.Date <= toDate)
            .ToListAsync();

        foreach (var e in expensesPaidFrom)
            entries.Add(new LedgerEntryDto
            {
                Date = e.Date,
                Reference = e.ExpenseNumber,
                Source = "Expense",
                Description = e.Memo ?? e.Vendor?.CompanyName,
                Debit = 0,
                Credit = e.Amount,
                LinkController = "Expenses",
                LinkId = e.Id
            });

        // ── 3. Bill payments made FROM this account (CREDIT) ──────────────────
        // e.g. Checking account used to pay a vendor bill
        var billPaymentsPaidFrom = await _context.BillPayments
            .Include(bp => bp.Bill)
            .Where(bp => bp.BankAccountId == accountId
                      && bp.PaymentDate >= fromDate && bp.PaymentDate <= toDate)
            .ToListAsync();

        foreach (var bp in billPaymentsPaidFrom)
            entries.Add(new LedgerEntryDto
            {
                Date = bp.PaymentDate,
                Reference = bp.PaymentNumber,
                Source = "Bill Payment",
                Description = bp.Memo ?? bp.Bill?.BillNumber,
                Debit = 0,
                Credit = bp.Amount,
                LinkController = "Bills",
                LinkId = bp.BillId
            });

        // ── 4. Invoice line items that post revenue to this account (CREDIT) ──
        // e.g. Revenue account 4000 receives line-item revenue
        var revenueItems = await _context.InvoiceItems
            .Include(ii => ii.Invoice)
            .Where(ii => ii.RevenueAccountId == accountId
                      && ii.Invoice.Status != InvoiceStatus.Draft
                      && ii.Invoice.Status != InvoiceStatus.Voided
                      && ii.Invoice.InvoiceDate >= fromDate && ii.Invoice.InvoiceDate <= toDate)
            .ToListAsync();

        foreach (var item in revenueItems)
            entries.Add(new LedgerEntryDto
            {
                Date = item.Invoice.InvoiceDate,
                Reference = item.Invoice.InvoiceNumber,
                Source = "Invoice",
                Description = item.Description,
                Debit = 0,
                Credit = item.TotalPrice,
                LinkController = "Invoices",
                LinkId = item.InvoiceId
            });

        // ── 5. Sales tax collected to this account (CREDIT) ───────────────────
        // e.g. Liability account 2200 receives sales tax from invoices
        var taxInvoices = await _context.Invoices
            .Where(i => i.SalesTaxAccountId == accountId
                     && i.TaxAmount > 0
                     && i.Status != InvoiceStatus.Draft
                     && i.Status != InvoiceStatus.Voided
                     && i.InvoiceDate >= fromDate && i.InvoiceDate <= toDate)
            .ToListAsync();

        foreach (var inv in taxInvoices)
            entries.Add(new LedgerEntryDto
            {
                Date = inv.InvoiceDate,
                Reference = inv.InvoiceNumber,
                Source = "Sales Tax",
                Description = $"Tax on {inv.InvoiceNumber}",
                Debit = 0,
                Credit = inv.TaxAmount,
                LinkController = "Invoices",
                LinkId = inv.Id
            });

        // ── 6. Direct expenses categorized to this account (DEBIT) ────────────
        // e.g. Expense account 6200 receives direct expense entries
        var expensesTo = await _context.Expenses
            .Include(e => e.Vendor)
            .Where(e => e.ExpenseAccountId == accountId
                     && e.Date >= fromDate && e.Date <= toDate)
            .ToListAsync();

        foreach (var e in expensesTo)
            entries.Add(new LedgerEntryDto
            {
                Date = e.Date,
                Reference = e.ExpenseNumber,
                Source = "Expense",
                Description = e.Memo ?? e.Vendor?.CompanyName,
                Debit = e.Amount,
                Credit = 0,
                LinkController = "Expenses",
                LinkId = e.Id
            });

        // ── 7. Bill line items categorized to this account (DEBIT) ────────────
        // e.g. Expense/COGS account receives costs from vendor bill line items
        var billLineItems = await _context.BillLineItems
            .Include(bli => bli.Bill)
            .Where(bli => bli.AccountId == accountId
                       && bli.Bill.Status != BillStatus.Draft
                       && bli.Bill.Status != BillStatus.Voided
                       && bli.Bill.BillDate >= fromDate && bli.Bill.BillDate <= toDate)
            .ToListAsync();

        foreach (var bli in billLineItems)
            entries.Add(new LedgerEntryDto
            {
                Date = bli.Bill.BillDate,
                Reference = bli.Bill.BillNumber,
                Source = "Bill",
                Description = bli.Description,
                Debit = bli.Amount,
                Credit = 0,
                LinkController = "Bills",
                LinkId = bli.BillId
            });

        // ── 8. Accounts Receivable ─────────────────────────────────────────────
        // Invoice creation increases AR (DEBIT); customer payments reduce AR (CREDIT)
        if (account.AccountSubType == AccountSubType.AccountsReceivable)
        {
            var arInvoices = await _context.Invoices
                .Include(i => i.Customer)
                .Where(i => i.Status != InvoiceStatus.Draft
                         && i.Status != InvoiceStatus.Voided
                         && i.InvoiceDate >= fromDate && i.InvoiceDate <= toDate)
                .ToListAsync();

            foreach (var inv in arInvoices)
            {
                var customerName = inv.Customer?.IsCommercial == true
                    ? inv.Customer.CompanyName
                    : $"{inv.Customer?.ContactFirstName} {inv.Customer?.ContactLastName}".Trim();

                entries.Add(new LedgerEntryDto
                {
                    Date = inv.InvoiceDate,
                    Reference = inv.InvoiceNumber,
                    Source = "Invoice",
                    Description = customerName,
                    Debit = inv.Total,
                    Credit = 0,
                    LinkController = "Invoices",
                    LinkId = inv.Id
                });
            }

            var arPayments = await _context.Payments
                .Include(p => p.Invoice)
                .Where(p => p.PaymentDate >= fromDate && p.PaymentDate <= toDate)
                .ToListAsync();

            foreach (var p in arPayments)
                entries.Add(new LedgerEntryDto
                {
                    Date = p.PaymentDate,
                    Reference = p.Invoice?.InvoiceNumber ?? $"PMT-{p.Id}",
                    Source = "Invoice Payment",
                    Description = $"Payment — {p.Invoice?.InvoiceNumber}",
                    Debit = 0,
                    Credit = p.Amount,
                    LinkController = "Invoices",
                    LinkId = p.InvoiceId
                });
        }

        // ── 9. Accounts Payable ────────────────────────────────────────────────
        // Bill creation increases AP (CREDIT); bill payments reduce AP (DEBIT)
        if (account.AccountSubType == AccountSubType.AccountsPayable)
        {
            var apBills = await _context.Bills
                .Include(b => b.Vendor)
                .Where(b => b.APAccountId == accountId
                         && b.Status != BillStatus.Draft
                         && b.Status != BillStatus.Voided
                         && b.BillDate >= fromDate && b.BillDate <= toDate)
                .ToListAsync();

            foreach (var b in apBills)
                entries.Add(new LedgerEntryDto
                {
                    Date = b.BillDate,
                    Reference = b.BillNumber,
                    Source = "Bill",
                    Description = b.Vendor?.CompanyName ?? b.Memo,
                    Debit = 0,
                    Credit = b.Total,
                    LinkController = "Bills",
                    LinkId = b.Id
                });

            var apPayments = await _context.BillPayments
                .Include(bp => bp.Bill)
                .Where(bp => bp.Bill.APAccountId == accountId
                          && bp.PaymentDate >= fromDate && bp.PaymentDate <= toDate)
                .ToListAsync();

            foreach (var bp in apPayments)
                entries.Add(new LedgerEntryDto
                {
                    Date = bp.PaymentDate,
                    Reference = bp.PaymentNumber,
                    Source = "Bill Payment",
                    Description = bp.Memo ?? bp.Bill?.BillNumber,
                    Debit = bp.Amount,
                    Credit = 0,
                    LinkController = "Bills",
                    LinkId = bp.BillId
                });
        }

        // ── Sort and compute running balance ──────────────────────────────────
        entries = entries
            .OrderBy(e => e.Date)
            .ThenBy(e => e.Reference)
            .ToList();

        // Derive normal-debit-balance flag from AccountSubType (more authoritative than AccountType,
        // since users could misconfigure AccountType while SubType is picked from a constrained list).
        bool normalDebitBalance = IsNormalDebitBalance(account.AccountSubType);

        // Compute the balance before the selected period
        decimal priorBalance = await ComputePriorBalanceAsync(account, fromDate, to.Date, normalDebitBalance);


        decimal runningBalance = priorBalance;
        foreach (var entry in entries)
        {
            runningBalance += normalDebitBalance
                ? entry.Debit - entry.Credit
                : entry.Credit - entry.Debit;
            entry.RunningBalance = runningBalance;
        }

        return new AccountLedgerDto
        {
            Id = account.Id,
            AccountNumber = account.AccountNumber,
            Name = account.Name,
            AccountType = account.AccountType,
            AccountSubType = account.AccountSubType,
            From = fromDate,
            To = to.Date,
            OpeningBalance = priorBalance,
            PeriodDebits = entries.Sum(e => e.Debit),
            PeriodCredits = entries.Sum(e => e.Credit),
            ClosingBalance = runningBalance,
            Entries = entries
        };
    }

    /// <summary>
    /// Returns <c>true</c> if the account sub-type has a normal debit balance (Assets, Expenses, COGS),
    /// <c>false</c> for normal credit balance (Liabilities, Equity, Revenue).
    /// <see cref="AccountSubType"/> is used rather than <see cref="PowderCoating.Core.Enums.AccountType"/>
    /// because sub-type is constrained to a known set of values and cannot be misconfigured by a user,
    /// whereas <c>AccountType</c> is a broader category that a user might set incorrectly.
    /// Expense enum values are ≥ 50 by convention, allowing a catch-all range match.
    /// </summary>
    private static bool IsNormalDebitBalance(AccountSubType subType) => subType switch
    {
        // Asset subtypes → normal debit balance
        AccountSubType.Checking
            or AccountSubType.Savings
            or AccountSubType.AccountsReceivable
            or AccountSubType.Inventory
            or AccountSubType.FixedAsset
            or AccountSubType.OtherCurrentAsset
            or AccountSubType.OtherAsset => true,

        // COGS → normal debit balance
        AccountSubType.CostOfGoodsSold => true,

        // Expense subtypes (enum values ≥ 50) → normal debit balance
        var st when (int)st >= 50 => true,

        // Liability subtypes (AP, CreditCard, etc.), Equity, Revenue → normal credit balance
        _ => false
    };

    /// <summary>
    /// Computes the account balance on the day immediately before <paramref name="beforeDate"/>
    /// by summing all activity prior to that date across every transaction source and adding
    /// the stored <c>OpeningBalance</c>. The opening balance is only included when its recorded
    /// date is on or before <paramref name="periodEnd"/> — a future-dated opening balance (e.g.
    /// from a mid-year chart-of-accounts migration) should not pollute earlier period reports.
    /// A null <c>OpeningBalanceDate</c> means the balance predates all transactions and always applies.
    /// The sign convention follows <see cref="IsNormalDebitBalance"/>: debits increase debit-normal
    /// accounts and credits increase credit-normal accounts.
    /// </summary>
    private async Task<decimal> ComputePriorBalanceAsync(
        PowderCoating.Core.Entities.Account account, DateTime beforeDate, DateTime periodEnd, bool normalDebitBalance)
    {
        var accountId = account.Id;
        decimal debits = 0;
        decimal credits = 0;

        // 1. Customer payments deposited INTO this account (DEBIT)
        debits += await _context.Payments
            .Where(p => p.DepositAccountId == accountId && p.PaymentDate < beforeDate)
            .SumAsync(p => (decimal?)p.Amount) ?? 0;

        // 2. Direct expenses paid FROM this account (CREDIT)
        credits += await _context.Expenses
            .Where(e => e.PaymentAccountId == accountId && e.Date < beforeDate)
            .SumAsync(e => (decimal?)e.Amount) ?? 0;

        // 3. Bill payments made FROM this account (CREDIT)
        credits += await _context.BillPayments
            .Where(bp => bp.BankAccountId == accountId && bp.PaymentDate < beforeDate)
            .SumAsync(bp => (decimal?)bp.Amount) ?? 0;

        // 4. Invoice line items posting revenue to this account (CREDIT)
        credits += await _context.InvoiceItems
            .Where(ii => ii.RevenueAccountId == accountId
                      && ii.Invoice.Status != InvoiceStatus.Draft
                      && ii.Invoice.Status != InvoiceStatus.Voided
                      && ii.Invoice.InvoiceDate < beforeDate)
            .SumAsync(ii => (decimal?)ii.TotalPrice) ?? 0;

        // 5. Sales tax collected to this account (CREDIT)
        credits += await _context.Invoices
            .Where(i => i.SalesTaxAccountId == accountId
                     && i.TaxAmount > 0
                     && i.Status != InvoiceStatus.Draft
                     && i.Status != InvoiceStatus.Voided
                     && i.InvoiceDate < beforeDate)
            .SumAsync(i => (decimal?)i.TaxAmount) ?? 0;

        // 6. Direct expenses categorized to this account (DEBIT)
        debits += await _context.Expenses
            .Where(e => e.ExpenseAccountId == accountId && e.Date < beforeDate)
            .SumAsync(e => (decimal?)e.Amount) ?? 0;

        // 7. Bill line items categorized to this account (DEBIT)
        debits += await _context.BillLineItems
            .Where(bli => bli.AccountId == accountId
                       && bli.Bill.Status != BillStatus.Draft
                       && bli.Bill.Status != BillStatus.Voided
                       && bli.Bill.BillDate < beforeDate)
            .SumAsync(bli => (decimal?)bli.Amount) ?? 0;

        // 8. Accounts Receivable
        if (account.AccountSubType == AccountSubType.AccountsReceivable)
        {
            debits += await _context.Invoices
                .Where(i => i.Status != InvoiceStatus.Draft
                         && i.Status != InvoiceStatus.Voided
                         && i.InvoiceDate < beforeDate)
                .SumAsync(i => (decimal?)i.Total) ?? 0;

            credits += await _context.Payments
                .Where(p => p.PaymentDate < beforeDate)
                .SumAsync(p => (decimal?)p.Amount) ?? 0;
        }

        // 9. Accounts Payable
        if (account.AccountSubType == AccountSubType.AccountsPayable)
        {
            credits += await _context.Bills
                .Where(b => b.APAccountId == accountId
                         && b.Status != BillStatus.Draft
                         && b.Status != BillStatus.Voided
                         && b.BillDate < beforeDate)
                .SumAsync(b => (decimal?)b.Total) ?? 0;

            debits += await _context.BillPayments
                .Where(bp => bp.Bill.APAccountId == accountId && bp.PaymentDate < beforeDate)
                .SumAsync(bp => (decimal?)bp.Amount) ?? 0;
        }

        decimal netActivity = normalDebitBalance ? debits - credits : credits - debits;

        // Apply the opening balance if it was established on or before the end of the viewed period.
        // A null date means it predates all transactions and always applies.
        decimal openingBalance = (account.OpeningBalanceDate == null || account.OpeningBalanceDate.Value.Date <= periodEnd)
            ? account.OpeningBalance
            : 0;

        return openingBalance + netActivity;
    }
}