BillTracker/services/trackerService.js

'use strict';

const { getDb } = require('../db/database');
const { buildTrackerRow, getCycleRange, resolveDueDate, roundMoney } = require('./statusService');
const { getUserSettings } = require('./userSettings');
const { computeBalanceDelta } = require('./billsService');
const { computeAmountSuggestion } = require('./amountSuggestionService');

const DEFAULT_PENDING_DAYS = 3;

function buildBankTracking(db, userId, year, month) {
  const settings = getUserSettings(userId);
  if (settings.bank_tracking_enabled !== 'true') return { enabled: false };

  const accountId = parseInt(settings.bank_tracking_account_id, 10);
  if (!Number.isInteger(accountId) || accountId < 1) return { enabled: false };

  const account = db.prepare(`
    SELECT id, name, org_name, balance, available_balance, updated_at
    FROM financial_accounts WHERE id = ? AND user_id = ?
  `).get(accountId, userId);
  if (!account || account.balance === null) return { enabled: false };

  const pendingDays = parseInt(settings.bank_tracking_pending_days, 10);
  const days = Number.isInteger(pendingDays) && pendingDays >= 0 ? pendingDays : DEFAULT_PENDING_DAYS;

  const pendingRow = days > 0
    ? db.prepare(`
        SELECT COALESCE(SUM(p.amount), 0) AS pending_total
        FROM payments p JOIN bills b ON b.id = p.bill_id
        WHERE b.user_id = ?
          AND p.paid_date >= date('now', '-' || ? || ' days')
          AND p.paid_date <= date('now') AND b.deleted_at IS NULL
      `).get(userId, days)
    : { pending_total: 0 };

  const { start, end } = getCycleRange(year, month);
  const unpaidRow = db.prepare(`
    SELECT COALESCE(SUM(
      CASE WHEN m.actual_amount IS NOT NULL THEN m.actual_amount
           ELSE COALESCE(b.expected_amount, 0) END
    ), 0) AS unpaid_total
    FROM bills b
    LEFT JOIN monthly_bill_state m ON m.bill_id = b.id AND m.year = ? AND m.month = ?
    LEFT JOIN (
      SELECT bill_id, SUM(amount) AS paid_sum FROM payments
      WHERE paid_date BETWEEN ? AND ? GROUP BY bill_id
    ) pay ON pay.bill_id = b.id
    WHERE b.user_id = ? AND b.active = 1 AND b.deleted_at IS NULL
      AND COALESCE(m.is_skipped, 0) = 0 AND COALESCE(pay.paid_sum, 0) = 0
  `).get(year, month, start, end, userId);

  const balance   = roundMoney(account.balance / 100);
  const pending   = roundMoney(pendingRow.pending_total);
  const effective = roundMoney(balance - pending);
  const unpaid    = roundMoney(unpaidRow.unpaid_total);

  return {
    enabled:           true,
    account_id:        account.id,
    account_name:      account.name,
    org_name:          account.org_name,
    balance,
    pending_payments:  pending,
    pending_days:      days,
    effective_balance: effective,
    unpaid_this_month: unpaid,
    remaining:         roundMoney(effective - unpaid),
    last_updated:      account.updated_at,
  };
}

function validateTrackerMonth(query = {}, now = new Date()) {
  const year = parseInt(query.year || now.getFullYear(), 10);
  const month = parseInt(query.month || now.getMonth() + 1, 10);

  if (Number.isNaN(year) || year < 2000 || year > 2100) {
    return { error: 'year must be a 4-digit integer between 2000 and 2100', status: 400 };
  }
  if (Number.isNaN(month) || month < 1 || month > 12) {
    return { error: 'month must be an integer between 1 and 12', status: 400 };
  }
  return { year, month };
}

function previousMonthFor(year, month) {
  return {
    year: month === 1 ? year - 1 : year,
    month: month === 1 ? 12 : month - 1,
  };
}

function monthOffset(year, month, offset) {
  let y = year;
  let m = month + offset;
  while (m <= 0) { m += 12; y -= 1; }
  while (m > 12) { m -= 12; y += 1; }
  return { year: y, month: m };
}

const FETCH_BILLS_ORDER = {
  due_day: 'CASE WHEN b.sort_order IS NULL THEN 1 ELSE 0 END, b.sort_order ASC, b.due_day ASC, b.name ASC',
  id:      'b.id ASC',
};

function fetchActiveBills(db, userId, orderKey = 'due_day') {
  const orderBy = FETCH_BILLS_ORDER[orderKey] ?? FETCH_BILLS_ORDER.due_day;
  return db.prepare(`
    SELECT b.*, c.name AS category_name
    FROM bills b
    LEFT JOIN categories c ON b.category_id = c.id AND c.deleted_at IS NULL
    WHERE b.active = 1 AND b.user_id = ? AND b.deleted_at IS NULL
    ORDER BY ${orderBy}
  `).all(userId);
}

function fetchMonthlyStates(db, billIds, year, month) {
  if (billIds.length === 0) return {};
  const placeholders = billIds.map(() => '?').join(',');
  const rows = db.prepare(`
    SELECT bill_id, actual_amount, notes, is_skipped, snoozed_until
    FROM monthly_bill_state
    WHERE bill_id IN (${placeholders}) AND year = ? AND month = ?
  `).all(...billIds, year, month);
  return Object.fromEntries(rows.map(row => [row.bill_id, row]));
}

function fetchPaymentsForBillCycle(db, bill, year, month) {
  const range = getCycleRange(year, month, bill);
  if (!range) return [];
  return db.prepare(`
    SELECT bill_id, id, amount, paid_date, method, notes, payment_source, transaction_id, created_at, updated_at
    FROM payments
    WHERE bill_id = ? AND paid_date BETWEEN ? AND ?
      AND deleted_at IS NULL
    ORDER BY paid_date DESC
  `).all(bill.id, range.start, range.end);
}

function fetchPreviousMonthPaid(db, billIds, range) {
  if (billIds.length === 0) return {};
  const placeholders = billIds.map(() => '?').join(',');
  const rows = db.prepare(`
    SELECT bill_id, SUM(amount) as total_paid
    FROM payments
    WHERE bill_id IN (${placeholders}) AND paid_date BETWEEN ? AND ?
      AND deleted_at IS NULL
    GROUP BY bill_id
  `).all(...billIds, range.start, range.end);
  return Object.fromEntries(rows.map(row => [row.bill_id, row.total_paid]));
}

function fetchDismissedSuggestions(db, userId, billIds, year, month) {
  if (billIds.length === 0) return new Set();
  const rows = db.prepare(`
    SELECT bill_id
    FROM autopay_suggestion_dismissals
    WHERE user_id = ? AND year = ? AND month = ?
  `).all(userId, year, month);
  return new Set(rows.map(row => row.bill_id));
}

function rowDueAmount(row) {
  const amount = Number(row.actual_amount ?? row.expected_amount);
  return Number.isFinite(amount) ? amount : 0;
}

function rowPaidTowardDue(row) {
  const cappedPaid = Number(row.paid_toward_due);
  if (Number.isFinite(cappedPaid)) return cappedPaid;
  return Math.min(Number(row.total_paid) || 0, rowDueAmount(row));
}

function applyAutopaySuggestions(db, bill, payments, mbs, year, month, todayStr, dismissedSuggestions) {
  const dueDate = resolveDueDate(bill, year, month);
  if (!dueDate) return null;

  const suggestedAmount = Number(mbs?.actual_amount ?? bill.expected_amount);
  const hasSuggestedAmount = Number.isFinite(suggestedAmount) && suggestedAmount > 0;
  const isEligible = !!(
    bill.autopay_enabled &&
    bill.autodraft_status === 'assumed_paid' &&
    hasSuggestedAmount &&
    dueDate <= todayStr &&
    !mbs?.is_skipped &&
    payments.length === 0
  );

  if (!isEligible) return null;

  if (bill.auto_mark_paid) {
    const range = getCycleRange(year, month, bill);
    const existingPayment = db.prepare(`
      SELECT bill_id, id, amount, paid_date, method, notes, payment_source, transaction_id, created_at, updated_at
      FROM payments
      WHERE bill_id = ?
        AND deleted_at IS NULL
        AND paid_date BETWEEN ? AND ?
      ORDER BY paid_date DESC
      LIMIT 1
    `).get(bill.id, range.start, range.end);

    if (existingPayment) {
      payments.push(existingPayment);
      return null;
    }

    const balCalc = computeBalanceDelta(bill, suggestedAmount);
    const result = db.prepare(`
      INSERT INTO payments (bill_id, amount, paid_date, method, notes, balance_delta, payment_source)
      VALUES (?, ?, ?, ?, ?, ?, ?)
    `).run(
      bill.id,
      suggestedAmount,
      dueDate,
      'autopay',
      'Auto-marked paid on due date',
      balCalc?.balance_delta ?? null,
      'manual',
    );

    if (balCalc) {
      db.prepare("UPDATE bills SET current_balance = ?, updated_at=datetime('now') WHERE id=?")
        .run(balCalc.new_balance, bill.id);
      bill.current_balance = balCalc.new_balance;
    }
    payments.push(db.prepare(`
      SELECT bill_id, id, amount, paid_date, method, notes, payment_source, transaction_id, created_at, updated_at
      FROM payments
      WHERE id = ?
    `).get(result.lastInsertRowid));
    return null;
  }

  if (dismissedSuggestions.has(bill.id)) return null;
  return {
    bill_id: bill.id,
    amount: suggestedAmount,
    paid_date: dueDate,
    method: 'autopay',
  };
}

function buildThreeMonthTrend(db, userId, year, month, end, currentMonthPaid) {
  const threeMonthsAgo = monthOffset(year, month, -2);
  const threeMonthStart = getCycleRange(threeMonthsAgo.year, threeMonthsAgo.month).start;
  const rows = db.prepare(`
    SELECT SUM(p.amount) as total_paid, strftime('%Y-%m', p.paid_date) as month_key
    FROM payments p
    JOIN bills b ON p.bill_id = b.id
    WHERE b.user_id = ? AND b.deleted_at IS NULL AND p.paid_date BETWEEN ? AND ?
      AND p.deleted_at IS NULL
    GROUP BY strftime('%Y-%m', p.paid_date)
  `).all(userId, threeMonthStart, end);

  const monthlyPaymentsMap = new Map();
  rows.forEach(payment => {
    monthlyPaymentsMap.set(payment.month_key, payment.total_paid);
  });

  const months = [];
  for (let i = 2; i >= 0; i--) {
    const date = new Date(year, month - 1 - i);
    const monthKey = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}`;
    months.push({
      year: date.getFullYear(),
      month: date.getMonth() + 1,
      key: monthKey,
      payment: parseFloat(monthlyPaymentsMap.get(monthKey) || 0),
    });
  }

  const threeMonthAvg = months.reduce((sum, m) => sum + m.payment, 0) / 3;
  let percentChange = 0;
  let direction = 'flat';
  if (threeMonthAvg > 0) {
    percentChange = ((currentMonthPaid - threeMonthAvg) / threeMonthAvg) * 100;
    if (percentChange > 2) direction = 'up';
    else if (percentChange < -2) direction = 'down';
  }

  return {
    three_month_avg: parseFloat(threeMonthAvg.toFixed(2)),
    current_month_paid: parseFloat(currentMonthPaid.toFixed(2)),
    percent_change: parseFloat(percentChange.toFixed(1)),
    direction,
  };
}

function getTracker(userId, query = {}, now = new Date()) {
  const parsed = validateTrackerMonth(query, now);
  if (parsed.error) return parsed;

  const db = getDb();
  const { year, month } = parsed;
  const todayStr = now.toISOString().slice(0, 10);
  const userSettings = getUserSettings(userId);
  const rowOptions = { gracePeriodDays: userSettings.grace_period_days };
  const { start, end } = getCycleRange(year, month);
  const previousMonth = previousMonthFor(year, month);
  const prevMonthRange = getCycleRange(previousMonth.year, previousMonth.month);

  const bills = fetchActiveBills(db, userId);
  const billIds = bills.map(bill => bill.id);
  const monthlyStates = fetchMonthlyStates(db, billIds, year, month);
  const prevMonthPayments = fetchPreviousMonthPaid(db, billIds, prevMonthRange);
  const dismissedSuggestions = fetchDismissedSuggestions(db, userId, billIds, year, month);

  const rows = bills.map(bill => {
    if (!resolveDueDate(bill, year, month)) return null;

    const payments = fetchPaymentsForBillCycle(db, bill, year, month);
    const mbs = monthlyStates[bill.id];
    const autopaySuggestion = applyAutopaySuggestions(
      db,
      bill,
      payments,
      mbs,
      year,
      month,
      todayStr,
      dismissedSuggestions,
    );

    const billForStatus = mbs?.actual_amount != null
      ? { ...bill, expected_amount: mbs.actual_amount }
      : bill;
    const row = buildTrackerRow(billForStatus, payments, year, month, todayStr, rowOptions);
    if (!row) return null;

    row.expected_amount = bill.expected_amount;
    row.actual_amount = mbs?.actual_amount ?? null;
    row.monthly_notes = mbs?.notes ?? null;
    row.is_skipped = !!(mbs?.is_skipped);
    row.snoozed_until = mbs?.snoozed_until ?? null;
    if (autopaySuggestion) row.autopay_suggestion = autopaySuggestion;
    row.previous_month_paid = prevMonthPayments[bill.id] || 0;
    row.amount_suggestion = computeAmountSuggestion(db, bill.id, year, month);
    return row;
  }).filter(Boolean);

  const activeRows = rows.filter(r => !r.is_skipped);
  const startingAmounts = db.prepare(`
    SELECT COALESCE(first_amount, 0) AS first_amount,
           COALESCE(fifteenth_amount, 0) AS fifteenth_amount,
           COALESCE(other_amount, 0) AS other_amount,
           COALESCE(first_amount, 0) + COALESCE(fifteenth_amount, 0) + COALESCE(other_amount, 0) AS combined_amount
    FROM monthly_starting_amounts
    WHERE user_id = ? AND year = ? AND month = ?
  `).get(userId, year, month);

  const dayOfMonth = now.getDate();
  const activeRemainingPeriod = dayOfMonth < 15 ? '1st' : '15th';
  const periodRows = activeRows.filter(r => r.bucket === activeRemainingPeriod);
  const periodPaidTowardDue = roundMoney(periodRows.reduce((s, r) => s + rowPaidTowardDue(r), 0));
  const periodOutstandingBalance = roundMoney(periodRows.reduce((s, r) => s + Math.max(r.balance || 0, 0), 0));
  const periodStartingAmount = activeRemainingPeriod === '1st'
    ? (startingAmounts?.first_amount || 0)
    : (startingAmounts?.fifteenth_amount || 0);
  const periodLabel = activeRemainingPeriod === '1st' ? '1st balance' : '15th balance';

  const bankTracking = buildBankTracking(db, userId, year, month);
  const totalStarting = bankTracking.enabled
    ? bankTracking.effective_balance
    : (startingAmounts?.combined_amount || 0);
  const hasStartingAmounts = bankTracking.enabled || !!startingAmounts;
  const activeTotalPaid = roundMoney(activeRows.reduce((s, r) => s + r.total_paid, 0));
  const activePaidTowardDue = roundMoney(activeRows.reduce((s, r) => s + rowPaidTowardDue(r), 0));
  const activeTotalExpected = roundMoney(activeRows.reduce((s, r) => s + rowDueAmount(r), 0));
  const activeOutstandingBalance = roundMoney(activeRows.reduce((s, r) => s + Math.max(r.balance || 0, 0), 0));
  const totalOverdue = roundMoney(rows
    .filter(r => !r.is_skipped && (r.status === 'late' || r.status === 'missed'))
    .reduce((s, r) => s + r.balance, 0));
  const previousMonthTotal = roundMoney(activeRows.reduce((s, r) => s + r.previous_month_paid, 0));

  return {
    year,
    month,
    today: todayStr,
    summary: {
      total_expected: activeTotalExpected,
      total_starting: totalStarting,
      has_starting_amounts: hasStartingAmounts,
      total_paid: activeTotalPaid,
      paid_toward_due: activePaidTowardDue,
      remaining: roundMoney(hasStartingAmounts ? periodStartingAmount - periodPaidTowardDue : periodOutstandingBalance),
      total_remaining: roundMoney(hasStartingAmounts ? totalStarting - activePaidTowardDue : activeOutstandingBalance),
      remaining_period: activeRemainingPeriod,
      remaining_label: periodLabel,
      remaining_hint: hasStartingAmounts
        ? `${periodLabel}: ${periodStartingAmount.toFixed(2)} starting minus ${periodPaidTowardDue.toFixed(2)} paid toward due`
        : `${periodLabel}: unpaid bills due in this period`,
      overdue: totalOverdue,
      count_paid: activeRows.filter(r => r.status === 'paid').length,
      count_upcoming: activeRows.filter(r => r.status === 'upcoming' || r.status === 'due_soon').length,
      count_late: activeRows.filter(r => r.status === 'late' || r.status === 'missed').length,
      count_autodraft: activeRows.filter(r => r.status === 'autodraft').length,
      previous_month_total: previousMonthTotal,
      trend: buildThreeMonthTrend(db, userId, year, month, end, activeTotalPaid),
    },
    bank_tracking: bankTracking,
    rows: bankTracking.enabled
      ? rows.map(r => {
          // Flag recently-paid rows as pending-cleared when bank tracking is on
          if (r.status === 'paid' && r.last_paid_date) {
            const cutoff = new Date();
            cutoff.setDate(cutoff.getDate() - bankTracking.pending_days);
            const paidAt = new Date(r.last_paid_date);
            return { ...r, pending_cleared: paidAt >= cutoff };
          }
          return { ...r, pending_cleared: false };
        })
      : rows,
  };
}

function getUpcomingBills(userId, query = {}, now = new Date()) {
  const db = getDb();
  const days = Math.max(1, Math.min(parseInt(query.days || '30', 10) || 30, 365));
  const todayStr = now.toISOString().slice(0, 10);
  const userSettings = getUserSettings(userId);
  const rowOptions = { gracePeriodDays: userSettings.grace_period_days };
  const bills = fetchActiveBills(db, userId, 'id');

  const cutoff = new Date(now);
  cutoff.setDate(cutoff.getDate() + days);
  const cutoffStr = cutoff.toISOString().slice(0, 10);
  const upcoming = [];
  const seen = new Set();
  const monthCount = (cutoff.getFullYear() - now.getFullYear()) * 12
    + (cutoff.getMonth() - now.getMonth()) + 1;

  for (let offset = 0; offset < monthCount; offset += 1) {
    const target = monthOffset(now.getFullYear(), now.getMonth() + 1, offset);

    for (const bill of bills) {
      const dueDate = resolveDueDate(bill, target.year, target.month);
      if (!dueDate || dueDate < todayStr || dueDate > cutoffStr) continue;

      const key = `${bill.id}:${dueDate}`;
      if (seen.has(key)) continue;
      seen.add(key);

      const row = buildTrackerRow(
        bill,
        fetchPaymentsForBillCycle(db, bill, target.year, target.month),
        target.year,
        target.month,
        todayStr,
        rowOptions,
      );
      if (!row || row.status === 'paid') continue;

      upcoming.push({
        id: bill.id,
        name: bill.name,
        category_name: bill.category_name,
        due_date: dueDate,
        expected_amount: bill.expected_amount,
        status: row.status,
        days_until_due: Math.floor((new Date(`${dueDate}T00:00:00`) - new Date(`${todayStr}T00:00:00`)) / 86400000),
      });
    }
  }

  upcoming.sort((a, b) => a.due_date.localeCompare(b.due_date));
  return { days, today: todayStr, upcoming };
}

function getOverdueCount(userId, now = new Date()) {
  const db = getDb();
  const todayStr = now.toISOString().slice(0, 10);
  const year  = now.getFullYear();
  const month = now.getMonth() + 1;
  const monthStr = String(month).padStart(2, '0');
  const rangeStart = `${year}-${monthStr}-01`;
  const lastDay    = new Date(year, month, 0).getDate();
  const rangeEnd   = `${year}-${monthStr}-${String(lastDay).padStart(2, '0')}`;

  const bills = db.prepare(`
    SELECT b.id, b.due_day, b.override_due_date, b.expected_amount,
           b.billing_cycle, b.cycle_type, b.cycle_day,
           b.autopay_enabled, b.autodraft_status,
           mbs.actual_amount, mbs.is_skipped, mbs.snoozed_until,
           COALESCE(SUM(p.amount), 0) AS total_paid
    FROM bills b
    LEFT JOIN monthly_bill_state mbs
      ON mbs.bill_id = b.id AND mbs.year = ? AND mbs.month = ?
    LEFT JOIN payments p
      ON p.bill_id = b.id AND p.paid_date BETWEEN ? AND ? AND p.deleted_at IS NULL
    WHERE b.user_id = ? AND b.active = 1 AND b.deleted_at IS NULL
    GROUP BY b.id
  `).all(year, month, rangeStart, rangeEnd, userId);

  let count = 0;
  for (const bill of bills) {
    if (bill.is_skipped) continue;
    if (bill.snoozed_until && bill.snoozed_until > todayStr) continue;
    if (bill.autopay_enabled && bill.autodraft_status === 'assumed_paid') continue;

    const dueDate = resolveDueDate(bill, year, month);
    if (!dueDate || dueDate > todayStr) continue;

    const threshold = bill.actual_amount != null ? bill.actual_amount : bill.expected_amount;
    if (threshold > 0 && bill.total_paid >= threshold) continue;

    count++;
  }

  return { count, month, year, today: todayStr };
}

module.exports = {
  getTracker,
  getUpcomingBills,
  validateTrackerMonth,
  getOverdueCount,
};