BillTracker/scripts/test-import.js

#!/usr/bin/env node
'use strict';

// Standalone test for the spreadsheet import parsing logic.
// Run: node scripts/test-import.js
// Does NOT require a running server or DB. Tests parsing functions directly.

const xlsx = require('xlsx');
const assert = require('assert');
const path = require('path');
const fs = require('fs');
const { execFileSync } = require('child_process');

// Import the two exported pure helpers directly from the service.
// They don't touch the DB, so this is safe without a DB connection.
const {
  parseSheetName,
  resolveYearMonth,
  findBillMatches: serviceFindBillMatches,
  buildRecommendation: serviceBuildRecommendation,
} = require('../services/spreadsheetImportService.cts');

// ─── Re-implement helpers for row-level tests (avoids DB init) ────────────────

function parseAmount(raw) {
  if (raw == null) return null;
  const str = String(raw).trim();
  if (!str) return null;
  const cleaned = str.replace(/[$,\s]/g, '').replace(/^\((.+)\)$/, '-$1');
  const val = parseFloat(cleaned);
  return Number.isFinite(val) ? val : null;
}

function parseDate(raw) {
  if (raw == null) return null;
  const str = String(raw).trim();
  if (!str) return null;
  let m = str.match(/^(\d{1,2})\/(\d{1,2})\/(\d{4})$/);
  if (m) {
    const [, mon, day, yr] = m;
    return {
      year: parseInt(yr, 10),
      month: parseInt(mon, 10),
      day: parseInt(day, 10),
      iso: `${yr}-${mon.padStart(2, '0')}-${day.padStart(2, '0')}`,
    };
  }
  m = str.match(/^(\d{4})-(\d{2})-(\d{2})$/);
  if (m)
    return {
      year: parseInt(m[1], 10),
      month: parseInt(m[2], 10),
      day: parseInt(m[3], 10),
      iso: str,
    };
  m = str.match(/^(\d{1,2})\/(\d{1,2})$/);
  if (m) return { year: null, month: parseInt(m[1], 10), day: parseInt(m[2], 10), iso: null };
  return null;
}

const LABEL_PATTERNS = {
  autopay: /\bauto(?:pay)?\b/i,
  past_due: /\bpast\s*due\b/i,
  double_pay: /\bdouble\s*pay\b/i,
  skipped: /\b(?:skip(?:ped)?|n\/?a|not\s*applicable)\b/i,
};
function detectLabels(text) {
  if (!text) return [];
  return Object.entries(LABEL_PATTERNS)
    .filter(([, p]) => p.test(text))
    .map(([l]) => l);
}

function normalizeName(name) {
  return String(name)
    .trim()
    .toLowerCase()
    .replace(/\s+/g, ' ')
    .replace(/[.,!?;:'"()]/g, '')
    .trim();
}

function isBlankRow(cells) {
  return cells.every((c) => c == null || String(c).trim() === '');
}
function isLikelyTotalRow(c) {
  return c.some(
    (v) => v != null && /^(?:total|subtotal|sum|grand\s*total)$/i.test(String(v).trim()),
  );
}
function isXlsxBuffer(buf) {
  return (
    Buffer.isBuffer(buf) &&
    buf.length >= 4 &&
    buf[0] === 0x50 &&
    buf[1] === 0x4b &&
    buf[2] === 0x03 &&
    buf[3] === 0x04
  );
}

// ─── Fixtures ─────────────────────────────────────────────────────────────────

function createSingleSheetXlsx() {
  const wb = xlsx.utils.book_new();
  const data = [
    ['Bill', 'Amount', 'Date', 'Notes'],
    ['Netflix', '$15.99', '5/1/2026', 'autopay'],
    ['Roadrunner ATV', '$1,460.62', '5/15/2026', ''],
    ['Discover (Austin)', '$39.60', '5/10/2026', 'past due'],
    ['', '', '', ''],
    ['Discover (Tilyn)', '$75.00', '5/10/2026', 'double pay'],
    ['RoadRunner', '$1,460.62', '5/15/2026', ''],
    ['TOTAL', '$3,051.21', '', ''],
    ['Unknown New Bill', '$250.00', '5/20/2026', 'auto'],
    ['Ghost Bill', '', '5/25/2026', ''],
    ['Partial Date Bill', '$100.00', '5/28', ''],
  ];
  const ws = xlsx.utils.aoa_to_sheet(data);
  xlsx.utils.book_append_sheet(wb, ws, 'May 2026');
  const ws2 = xlsx.utils.aoa_to_sheet([['Other', '$1.00']]);
  xlsx.utils.book_append_sheet(wb, ws2, 'Summary');
  return xlsx.write(wb, { type: 'buffer', bookType: 'xlsx' });
}

function createMultiSheetXlsx() {
  const wb = xlsx.utils.book_new();

  // Tab 1: Jan 2026 — full month/year in name
  const jan = [
    ['Bill', 'Amount', 'Notes'],
    ['Netflix', '$15.99', 'autopay'],
    ['Electric', '$120.00', ''],
    ['', '', ''],
    ['TOTAL', '$135.99', ''],
  ];
  xlsx.utils.book_append_sheet(wb, xlsx.utils.aoa_to_sheet(jan), 'Jan 2026');

  // Tab 2: Feb 2026 — full month/year, different format
  const feb = [
    ['Bill', 'Amount', 'Notes'],
    ['Netflix', '$15.99', ''],
    ['Internet', '$59.99', 'auto'],
  ];
  xlsx.utils.book_append_sheet(wb, xlsx.utils.aoa_to_sheet(feb), 'Feb 2026');

  // Tab 3: Summary — should be skipped (non-month)
  const summary = [
    ['Month', 'Total'],
    ['Jan 2026', '$135.99'],
    ['Feb 2026', '$75.98'],
  ];
  xlsx.utils.book_append_sheet(wb, xlsx.utils.aoa_to_sheet(summary), 'Summary');

  // Tab 4: May — month only, needs default_year
  const may = [
    ['Bill', 'Amount', 'Notes'],
    ['Water', '$45.00', ''],
    ['Gas', '$30.00', 'past due'],
  ];
  xlsx.utils.book_append_sheet(wb, xlsx.utils.aoa_to_sheet(may), 'May');

  // Tab 5: Ambiguous — no month or year
  const ambiguous = [
    ['Bill', 'Amount'],
    ['Mystery Bill', '$99.00'],
  ];
  xlsx.utils.book_append_sheet(wb, xlsx.utils.aoa_to_sheet(ambiguous), 'Misc Data');

  return xlsx.write(wb, { type: 'buffer', bookType: 'xlsx' });
}

// ─── Test runner ──────────────────────────────────────────────────────────────

let passed = 0;
let failed = 0;

function test(name, fn) {
  try {
    fn();
    console.log(`  ✓ ${name}`);
    passed++;
  } catch (err) {
    console.error(`  ✗ ${name}\n    ${err.message}`);
    failed++;
  }
}

// ─── parseSheetName ───────────────────────────────────────────────────────────
console.log('\n── parseSheetName — month+year patterns ─────────────────────────');
test('"Jan 2026"', () => {
  const r = parseSheetName('Jan 2026');
  assert.deepStrictEqual({ year: r.year, month: r.month }, { year: 2026, month: 1 });
});
test('"January 2026"', () => {
  const r = parseSheetName('January 2026');
  assert.deepStrictEqual({ year: r.year, month: r.month }, { year: 2026, month: 1 });
});
test('"Feb 2025"', () => {
  const r = parseSheetName('Feb 2025');
  assert.deepStrictEqual({ year: r.year, month: r.month }, { year: 2025, month: 2 });
});
test('"March 2026"', () => {
  const r = parseSheetName('March 2026');
  assert.deepStrictEqual({ year: r.year, month: r.month }, { year: 2026, month: 3 });
});
test('"2026-01"', () => {
  const r = parseSheetName('2026-01');
  assert.deepStrictEqual({ year: r.year, month: r.month }, { year: 2026, month: 1 });
});
test('"2026-5"', () => {
  const r = parseSheetName('2026-5');
  assert.deepStrictEqual({ year: r.year, month: r.month }, { year: 2026, month: 5 });
});
test('"01-2026"', () => {
  const r = parseSheetName('01-2026');
  assert.deepStrictEqual({ year: r.year, month: r.month }, { year: 2026, month: 1 });
});
test('"02-2026"', () => {
  const r = parseSheetName('02-2026');
  assert.deepStrictEqual({ year: r.year, month: r.month }, { year: 2026, month: 2 });
});
test('"Bills May 2026"', () => {
  const r = parseSheetName('Bills May 2026');
  assert.deepStrictEqual({ year: r.year, month: r.month }, { year: 2026, month: 5 });
});
test('"2026 May"', () => {
  const r = parseSheetName('2026 May');
  assert.deepStrictEqual({ year: r.year, month: r.month }, { year: 2026, month: 5 });
});
test('"September 2026"', () => {
  const r = parseSheetName('September 2026');
  assert.deepStrictEqual({ year: r.year, month: r.month }, { year: 2026, month: 9 });
});
test('"Sept 2026"', () => {
  const r = parseSheetName('Sept 2026');
  assert.deepStrictEqual({ year: r.year, month: r.month }, { year: 2026, month: 9 });
});
test('"Dec 2025"', () => {
  const r = parseSheetName('Dec 2025');
  assert.deepStrictEqual({ year: r.year, month: r.month }, { year: 2025, month: 12 });
});
test('"July2017"', () => {
  const r = parseSheetName('July2017');
  assert.deepStrictEqual({ year: r.year, month: r.month }, { year: 2017, month: 7 });
});
test('"August2017"', () => {
  const r = parseSheetName('August2017');
  assert.deepStrictEqual({ year: r.year, month: r.month }, { year: 2017, month: 8 });
});
test('"September2017"', () => {
  const r = parseSheetName('September2017');
  assert.deepStrictEqual({ year: r.year, month: r.month }, { year: 2017, month: 9 });
});
test('"Januaru 2021"', () => {
  const r = parseSheetName('Januaru 2021');
  assert.deepStrictEqual({ year: r.year, month: r.month }, { year: 2021, month: 1 });
});
test('"Febuary 2023"', () => {
  const r = parseSheetName('Febuary 2023');
  assert.deepStrictEqual({ year: r.year, month: r.month }, { year: 2023, month: 2 });
});
test('"Novevmber 2019"', () => {
  const r = parseSheetName('Novevmber 2019');
  assert.deepStrictEqual({ year: r.year, month: r.month }, { year: 2019, month: 11 });
});

console.log('\n── parseSheetName — month only (no year) ────────────────────────');
test('"May"', () => {
  const r = parseSheetName('May');
  assert.strictEqual(r.month, 5);
  assert.strictEqual(r.year, null);
  assert.strictEqual(r.is_non_month_sheet, false);
});
test('"May Bills"', () => {
  const r = parseSheetName('May Bills');
  assert.strictEqual(r.month, 5);
  assert.strictEqual(r.year, null);
});
test('"January"', () => {
  const r = parseSheetName('January');
  assert.strictEqual(r.month, 1);
  assert.strictEqual(r.year, null);
});
test('"Oct"', () => {
  const r = parseSheetName('Oct');
  assert.strictEqual(r.month, 10);
});

console.log('\n── parseSheetName — known non-month sheets ──────────────────────');
test('"Summary"', () => assert.strictEqual(parseSheetName('Summary').is_non_month_sheet, true));
test('"Totals"', () => assert.strictEqual(parseSheetName('Totals').is_non_month_sheet, true));
test('"Total"', () => assert.strictEqual(parseSheetName('Total').is_non_month_sheet, true));
test('"Dashboard"', () => assert.strictEqual(parseSheetName('Dashboard').is_non_month_sheet, true));
test('"Notes"', () => assert.strictEqual(parseSheetName('Notes').is_non_month_sheet, true));
test('"Categories"', () =>
  assert.strictEqual(parseSheetName('Categories').is_non_month_sheet, true));
test('"Settings"', () => assert.strictEqual(parseSheetName('Settings').is_non_month_sheet, true));
test('"Overview"', () => assert.strictEqual(parseSheetName('Overview').is_non_month_sheet, true));
test('"Template"', () => assert.strictEqual(parseSheetName('Template').is_non_month_sheet, true));
test('"Info"', () => assert.strictEqual(parseSheetName('Info').is_non_month_sheet, true));
test('"2018 taxes"', () =>
  assert.strictEqual(parseSheetName('2018 taxes').is_non_month_sheet, true));
test('"debt totoals"', () =>
  assert.strictEqual(parseSheetName('debt totoals').is_non_month_sheet, true));
test('"Sheet13"', () => assert.strictEqual(parseSheetName('Sheet13').is_non_month_sheet, true));

console.log('\n── parseSheetName — ambiguous (no month, not non-month) ─────────');
test('"Misc Data"', () => {
  const r = parseSheetName('Misc Data');
  assert.strictEqual(r.month, null);
  assert.strictEqual(r.is_non_month_sheet, false);
});
test('"Q1"', () => {
  const r = parseSheetName('Q1');
  assert.strictEqual(r.month, null);
  assert.strictEqual(r.is_non_month_sheet, false);
});
test('"1st - 14th"', () => {
  const r = parseSheetName('1st - 14th');
  assert.strictEqual(r.month, null);
  assert.strictEqual(r.is_non_month_sheet, false);
});
test('empty string', () => {
  const r = parseSheetName('');
  assert.strictEqual(r.month, null);
  assert.strictEqual(r.is_non_month_sheet, false);
});

// ─── resolveYearMonth ─────────────────────────────────────────────────────────
console.log('\n── resolveYearMonth — source tracking ───────────────────────────');
test('full date in row → row_date', () => {
  const r = resolveYearMonth(
    { year: 2026, month: 5, day: 1, iso: '2026-05-01' },
    null,
    null,
    null,
    null,
  );
  assert.strictEqual(r.source, 'row_date');
  assert.strictEqual(r.year, 2026);
  assert.strictEqual(r.month, 5);
});
test('partial date + sheetYear → sheet_name', () => {
  const r = resolveYearMonth({ year: null, month: 5, day: 10, iso: null }, 2026, null, null, null);
  assert.strictEqual(r.source, 'sheet_name');
  assert.strictEqual(r.year, 2026);
  assert.strictEqual(r.month, 5);
});
test('partial date + defaultYear → default', () => {
  const r = resolveYearMonth({ year: null, month: 3, day: 5, iso: null }, null, null, 2025, null);
  assert.strictEqual(r.source, 'default');
  assert.strictEqual(r.year, 2025);
  assert.strictEqual(r.month, 3);
});
test('partial date, no year anywhere → ambiguous', () => {
  const r = resolveYearMonth({ year: null, month: 5, day: 10, iso: null }, null, null, null, null);
  assert.strictEqual(r.source, 'ambiguous');
  assert.strictEqual(r.year, null);
  assert.ok(r.warnings.length > 0, 'should have warning');
});
test('no row date, sheetMonth+sheetYear → sheet_name', () => {
  const r = resolveYearMonth(null, 2026, 1, null, null);
  assert.strictEqual(r.source, 'sheet_name');
  assert.strictEqual(r.year, 2026);
  assert.strictEqual(r.month, 1);
});
test('no row date, sheetMonth no year, defaultYear → sheet_name', () => {
  const r = resolveYearMonth(null, null, 5, 2026, null);
  assert.strictEqual(r.source, 'sheet_name');
  assert.strictEqual(r.year, 2026);
  assert.strictEqual(r.month, 5);
});
test('no row date, sheetMonth no year, no defaultYear → ambiguous', () => {
  const r = resolveYearMonth(null, null, 5, null, null);
  assert.strictEqual(r.source, 'ambiguous');
  assert.strictEqual(r.year, null);
  assert.strictEqual(r.month, 5);
  assert.ok(r.warnings.some((w) => w.includes('Year unknown')));
});
test('no row date, no sheet, defaults present → default', () => {
  const r = resolveYearMonth(null, null, null, 2026, 4);
  assert.strictEqual(r.source, 'default');
  assert.strictEqual(r.year, 2026);
  assert.strictEqual(r.month, 4);
});
test('nothing available → ambiguous', () => {
  const r = resolveYearMonth(null, null, null, null, null);
  assert.strictEqual(r.source, 'ambiguous');
  assert.strictEqual(r.year, null);
  assert.strictEqual(r.month, null);
});

// ─── parseAmount ──────────────────────────────────────────────────────────────
console.log('\n── parseAmount ──────────────────────────────────────────────────');
test('plain number', () => assert.strictEqual(parseAmount('15.99'), 15.99));
test('dollar + commas', () => assert.strictEqual(parseAmount('$1,460.62'), 1460.62));
test('bare integer', () => assert.strictEqual(parseAmount('39'), 39));
test('zero', () => assert.strictEqual(parseAmount('0'), 0));
test('null for empty', () => assert.strictEqual(parseAmount(''), null));
test('null for text', () => assert.strictEqual(parseAmount('autopay'), null));
test('null for null', () => assert.strictEqual(parseAmount(null), null));
test('accounting negative', () => assert.strictEqual(parseAmount('(50.00)'), -50.0));

// ─── parseDate ────────────────────────────────────────────────────────────────
console.log('\n── parseDate ────────────────────────────────────────────────────');
test('MM/DD/YYYY', () =>
  assert.deepStrictEqual(parseDate('5/1/2026'), {
    year: 2026,
    month: 5,
    day: 1,
    iso: '2026-05-01',
  }));
test('YYYY-MM-DD', () =>
  assert.deepStrictEqual(parseDate('2026-05-15'), {
    year: 2026,
    month: 5,
    day: 15,
    iso: '2026-05-15',
  }));
test('MM/DD no yr', () =>
  assert.deepStrictEqual(parseDate('5/28'), { year: null, month: 5, day: 28, iso: null }));
test('null empty', () => assert.strictEqual(parseDate(''), null));
test('null text', () => assert.strictEqual(parseDate('autopay'), null));

// ─── detectLabels ─────────────────────────────────────────────────────────────
console.log('\n── detectLabels ─────────────────────────────────────────────────');
test('autopay', () => assert.deepStrictEqual(detectLabels('autopay'), ['autopay']));
test('auto', () => assert.deepStrictEqual(detectLabels('auto'), ['autopay']));
test('past_due', () => assert.deepStrictEqual(detectLabels('past due'), ['past_due']));
test('double_pay', () => assert.deepStrictEqual(detectLabels('double pay'), ['double_pay']));
test('N/A', () => assert.deepStrictEqual(detectLabels('N/A'), ['skipped']));
test('multiple', () => {
  const l = detectLabels('past due double pay');
  assert.ok(l.includes('past_due') && l.includes('double_pay'));
});
test('none', () => assert.deepStrictEqual(detectLabels('Netflix'), []));

// ─── normalizeName ────────────────────────────────────────────────────────────
console.log('\n── normalizeName ────────────────────────────────────────────────');
test('lowercases + trims', () => assert.strictEqual(normalizeName('  Netflix  '), 'netflix'));
test('collapses spaces', () => assert.strictEqual(normalizeName('Road  Runner'), 'road runner'));
test('strips punctuation', () => assert.strictEqual(normalizeName('Discover.'), 'discover'));
test('strips parens around text', () =>
  assert.strictEqual(normalizeName('Discover (Austin)'), 'discover austin'));

// ─── recommendation logic ─────────────────────────────────────────────────────
console.log('\n── recommendation logic ─────────────────────────────────────────');
const recBills = [
  {
    id: 1,
    name: 'Capital One',
    category_id: 4,
    category_name: 'Credit Cards',
    due_day: 10,
    expected_amount: 85.23,
  },
  {
    id: 2,
    name: 'Austin Discover',
    category_id: 4,
    category_name: 'Credit Cards',
    due_day: 12,
    expected_amount: 39.6,
  },
  {
    id: 3,
    name: 'Roadrunner ATV',
    category_id: 5,
    category_name: 'Loans',
    due_day: 15,
    expected_amount: 1460.62,
  },
  {
    id: 4,
    name: 'Roadrunner Internet',
    category_id: 2,
    category_name: 'Utilities',
    due_day: 8,
    expected_amount: 79.99,
  },
  {
    id: 5,
    name: 'Netflix',
    category_id: 3,
    category_name: 'Subscriptions',
    due_day: 1,
    expected_amount: 15.99,
  },
];
const recCategories = [
  { id: 2, name: 'Utilities' },
  { id: 3, name: 'Subscriptions' },
  { id: 4, name: 'Credit Cards' },
  { id: 5, name: 'Loans' },
];
const baseRecInput = {
  detectedAmount: 85.23,
  parsedDate: { year: 2026, month: 5, day: 12, iso: '2026-05-12' },
  dateHeader: 'Due Date',
  detectedCategory: null,
  notesText: null,
  categories: recCategories,
  warnings: [],
  errors: [],
};
test('"Capital" matches existing "Capital One"', () => {
  const matches = serviceFindBillMatches('Capital', recBills);
  assert.strictEqual(matches[0].bill_id, 1);
  assert.ok(['medium', 'high'].includes(matches[0].match_confidence));
});
test('"Cap One" matches existing "Capital One"', () => {
  const matches = serviceFindBillMatches('Cap One', recBills);
  assert.strictEqual(matches[0].bill_id, 1);
  assert.ok(['medium', 'high'].includes(matches[0].match_confidence));
});
test('existing bill exact match recommends match_existing_bill', () => {
  const possibleMatches = serviceFindBillMatches('Netflix', recBills);
  const rec = serviceBuildRecommendation({
    ...baseRecInput,
    billName: 'Netflix',
    detectedAmount: 15.99,
    possibleMatches,
  });
  assert.strictEqual(rec.action, 'match_existing_bill');
  assert.strictEqual(rec.bill_id, 5);
  assert.strictEqual(rec.confidence, 'high');
});
test('weak/ambiguous match with multiple candidates requires decision', () => {
  const possibleMatches = serviceFindBillMatches('Roadrunner', recBills);
  const rec = serviceBuildRecommendation({
    ...baseRecInput,
    billName: 'Roadrunner',
    possibleMatches,
  });
  assert.strictEqual(rec.action, 'ambiguous');
  assert.ok(possibleMatches.length >= 2);
});
test('no match recommends create_new_bill', () => {
  const possibleMatches = serviceFindBillMatches('New Gym', recBills);
  const rec = serviceBuildRecommendation({ ...baseRecInput, billName: 'New Gym', possibleMatches });
  assert.strictEqual(rec.action, 'create_new_bill');
  assert.strictEqual(rec.bill_name, 'New Gym');
});
test('category recommendation uses existing category', () => {
  const rec = serviceBuildRecommendation({
    ...baseRecInput,
    billName: 'Electric',
    detectedAmount: 120,
    possibleMatches: [],
  });
  assert.strictEqual(rec.action, 'create_new_bill');
  assert.strictEqual(rec.category_id, 2);
  assert.strictEqual(rec.category_name, 'Utilities');
});
test('due date parsed into due_day', () => {
  const possibleMatches = serviceFindBillMatches('Capital One', recBills);
  const rec = serviceBuildRecommendation({
    ...baseRecInput,
    billName: 'Capital One',
    possibleMatches,
  });
  assert.strictEqual(rec.due_day, 12);
});
test('due day mismatch warning', () => {
  const possibleMatches = serviceFindBillMatches('Capital One', recBills);
  const rec = serviceBuildRecommendation({
    ...baseRecInput,
    billName: 'Capital One',
    possibleMatches,
  });
  assert.ok(rec.warnings.includes('Spreadsheet due day differs from current bill due day'));
});
test('amount mismatch warning', () => {
  const possibleMatches = serviceFindBillMatches('Capital One', recBills);
  const rec = serviceBuildRecommendation({
    ...baseRecInput,
    billName: 'Capital One',
    detectedAmount: 99,
    possibleMatches,
  });
  assert.ok(rec.warnings.includes('Spreadsheet amount differs from current bill expected amount'));
});
test('summary/blank rows still skipped', () => {
  const rec = serviceBuildRecommendation({
    ...baseRecInput,
    billName: null,
    detectedAmount: null,
    possibleMatches: [],
    warnings: ['No amount detected'],
    errors: ['No bill name detected'],
  });
  assert.strictEqual(rec.action, 'skip_row');
});

// ─── row classification ───────────────────────────────────────────────────────
console.log('\n── row classification ───────────────────────────────────────────');
test('blank row', () => assert.ok(isBlankRow(['', '', null, '   '])));
test('non-blank row', () => assert.ok(!isBlankRow(['Netflix', '$15', '', ''])));
test('total row', () => assert.ok(isLikelyTotalRow(['TOTAL', '$3,051', '', ''])));
test('non-total row', () => assert.ok(!isLikelyTotalRow(['Netflix', '$15', '', ''])));

// ─── XLSX magic bytes ─────────────────────────────────────────────────────────
console.log('\n── XLSX magic bytes ─────────────────────────────────────────────');
test('valid XLSX accepted', () => assert.ok(isXlsxBuffer(createSingleSheetXlsx())));
test('random buffer rejected', () => assert.ok(!isXlsxBuffer(Buffer.from([0, 1, 2, 3]))));
test('empty buffer rejected', () => assert.ok(!isXlsxBuffer(Buffer.alloc(0))));

// ─── Single-sheet XLSX round-trip ─────────────────────────────────────────────
console.log('\n── Single-sheet XLSX round-trip ─────────────────────────────────');
test('valid buffer', () => {
  const buf = createSingleSheetXlsx();
  assert.ok(isXlsxBuffer(buf));
  assert.ok(buf.length > 100);
});
test('rows correct', () => {
  const buf = createSingleSheetXlsx();
  const wb = xlsx.read(buf, { type: 'buffer', cellFormula: false });
  const rows = xlsx.utils.sheet_to_json(wb.Sheets['May 2026'], {
    header: 1,
    defval: null,
    raw: false,
  });
  assert.strictEqual(rows[0][0], 'Bill');
  assert.strictEqual(rows[1][0], 'Netflix');
  assert.strictEqual(rows[1][1], '$15.99');
  assert.strictEqual(rows[1][3], 'autopay');
  assert.ok(isBlankRow(rows[4] || []), 'row 4 blank');
  assert.strictEqual(rows[7][0], 'TOTAL');
  assert.strictEqual(wb.SheetNames[1], 'Summary');
});
test('amounts parse', () => {
  const buf = createSingleSheetXlsx();
  const rows = xlsx.utils.sheet_to_json(
    xlsx.read(buf, { type: 'buffer', cellFormula: false }).Sheets['May 2026'],
    { header: 1, defval: null, raw: false },
  );
  assert.strictEqual(parseAmount(rows[1][1]), 15.99);
  assert.strictEqual(parseAmount(rows[2][1]), 1460.62);
  assert.strictEqual(parseAmount(rows[9][1]), null, 'Ghost Bill no amount');
});
test('labels in rows', () => {
  const buf = createSingleSheetXlsx();
  const rows = xlsx.utils.sheet_to_json(
    xlsx.read(buf, { type: 'buffer', cellFormula: false }).Sheets['May 2026'],
    { header: 1, defval: null, raw: false },
  );
  assert.ok(detectLabels(String(rows[1][3] || '')).includes('autopay'));
  assert.ok(detectLabels(String(rows[3][3] || '')).includes('past_due'));
  assert.ok(detectLabels(String(rows[5][3] || '')).includes('double_pay'));
});
test('partial date parsed', () => {
  const buf = createSingleSheetXlsx();
  const rows = xlsx.utils.sheet_to_json(
    xlsx.read(buf, { type: 'buffer', cellFormula: false }).Sheets['May 2026'],
    { header: 1, defval: null, raw: false },
  );
  const d = parseDate(rows[10][2]);
  assert.strictEqual(d.month, 5);
  assert.strictEqual(d.day, 28);
  assert.strictEqual(d.year, null);
});

// ─── Multi-sheet XLSX round-trip ──────────────────────────────────────────────
console.log('\n── Multi-sheet XLSX round-trip ──────────────────────────────────');
test('creates valid XLSX', () => {
  const b = createMultiSheetXlsx();
  assert.ok(isXlsxBuffer(b));
});
test('has 5 sheets', () => {
  const wb = xlsx.read(createMultiSheetXlsx(), { type: 'buffer', cellFormula: false });
  assert.strictEqual(wb.SheetNames.length, 5);
  assert.deepStrictEqual(wb.SheetNames, ['Jan 2026', 'Feb 2026', 'Summary', 'May', 'Misc Data']);
});
test('Jan 2026 sheet → year=2026 month=1', () => {
  const r = parseSheetName('Jan 2026');
  assert.strictEqual(r.year, 2026);
  assert.strictEqual(r.month, 1);
  assert.strictEqual(r.is_non_month_sheet, false);
});
test('Feb 2026 sheet → year=2026 month=2', () => {
  const r = parseSheetName('Feb 2026');
  assert.strictEqual(r.year, 2026);
  assert.strictEqual(r.month, 2);
});
test('Summary sheet → non-month', () => {
  assert.strictEqual(parseSheetName('Summary').is_non_month_sheet, true);
});
test('May sheet → month=5, no year', () => {
  const r = parseSheetName('May');
  assert.strictEqual(r.month, 5);
  assert.strictEqual(r.year, null);
  assert.strictEqual(r.is_non_month_sheet, false);
});
test('May + default_year=2026 → sheet_name source', () => {
  const r = resolveYearMonth(null, null, 5, 2026, null);
  assert.strictEqual(r.month, 5);
  assert.strictEqual(r.year, 2026);
  assert.strictEqual(r.source, 'sheet_name');
});
test('Misc Data → ambiguous, no month', () => {
  const r = parseSheetName('Misc Data');
  assert.strictEqual(r.month, null);
  assert.strictEqual(r.is_non_month_sheet, false);
});
test('Jan rows have no dates → sheet provides year/month', () => {
  const wb = xlsx.read(createMultiSheetXlsx(), { type: 'buffer', cellFormula: false });
  const rows = xlsx.utils.sheet_to_json(wb.Sheets['Jan 2026'], {
    header: 1,
    defval: null,
    raw: false,
  });
  // Row 1 (Netflix) has no date cell — year/month should come from sheet name
  const { year: sy, month: sm } = parseSheetName('Jan 2026');
  const resolved = resolveYearMonth(null, sy, sm, null, null);
  assert.strictEqual(resolved.year, 2026);
  assert.strictEqual(resolved.month, 1);
  assert.strictEqual(resolved.source, 'sheet_name');
});
test('blank/total rows in Jan sheet', () => {
  const wb = xlsx.read(createMultiSheetXlsx(), { type: 'buffer', cellFormula: false });
  const rows = xlsx.utils.sheet_to_json(wb.Sheets['Jan 2026'], {
    header: 1,
    defval: null,
    raw: false,
  });
  assert.ok(isBlankRow(rows[3] || []), 'blank row in Jan');
  assert.ok(isLikelyTotalRow(rows[4] || []), 'total row in Jan');
});
test('May amounts parse correctly', () => {
  const wb = xlsx.read(createMultiSheetXlsx(), { type: 'buffer', cellFormula: false });
  const rows = xlsx.utils.sheet_to_json(wb.Sheets['May'], { header: 1, defval: null, raw: false });
  assert.strictEqual(parseAmount(rows[1][1]), 45.0, 'Water $45');
  assert.strictEqual(parseAmount(rows[2][1]), 30.0, 'Gas $30');
});
test('past_due label in May Gas row', () => {
  const wb = xlsx.read(createMultiSheetXlsx(), { type: 'buffer', cellFormula: false });
  const rows = xlsx.utils.sheet_to_json(wb.Sheets['May'], { header: 1, defval: null, raw: false });
  assert.ok(detectLabels(String(rows[2][2] || '')).includes('past_due'));
});

// ─── Apply preserves tab-derived year/month ───────────────────────────────────
console.log('\n── apply: tab-derived year/month preserved in resolveYear/Month ─');
test('sheet-derived year flows through resolveYear', () => {
  // Simulate previewRow as stored in session (detected_year came from sheet name)
  const previewRow = { detected_year: 2026, detected_month: 1 };
  const sessionData = { default_year: null, default_month: null };
  const decision = { row_id: 's0_r1', action: 'match_existing_bill', bill_id: 1 };
  // resolveYear reads previewRow.detected_year which was populated from sheet name during preview
  const yr = decision.year ?? previewRow.detected_year ?? sessionData.default_year ?? null;
  const mo = decision.month ?? previewRow.detected_month ?? sessionData.default_month ?? null;
  assert.strictEqual(yr, 2026, 'year from sheet name preserved');
  assert.strictEqual(mo, 1, 'month from sheet name preserved');
});
test('decision year overrides sheet-derived year', () => {
  const previewRow = { detected_year: 2026, detected_month: 1 };
  const sessionData = { default_year: null };
  const decision = { year: 2025 }; // explicit override
  const yr = decision.year ?? previewRow.detected_year ?? sessionData.default_year ?? null;
  assert.strictEqual(yr, 2025, 'explicit decision year wins');
});

// ─── Apply regression: match existing bill ───────────────────────────────────
console.log('\n── apply: match_existing_bill regression ────────────────────────');

function runApplyRegression(name, body) {
  test(name, () => {
    const dbPath = path.join(
      '/tmp',
      `bill-tracker-import-${process.pid}-${name.replace(/[^a-z0-9]+/gi, '-')}.sqlite`,
    );
    try {
      fs.unlinkSync(dbPath);
    } catch {}
    execFileSync(process.execPath, ['-e', body], {
      cwd: path.join(__dirname, '..'),
      env: { ...process.env, DB_PATH: dbPath },
      stdio: ['ignore', 'pipe', 'pipe'],
    });
    try {
      fs.unlinkSync(dbPath);
    } catch {}
    try {
      fs.unlinkSync(`${dbPath}-wal`);
    } catch {}
    try {
      fs.unlinkSync(`${dbPath}-shm`);
    } catch {}
  });
}

const APPLY_SETUP = `
const assert = require('assert');
const xlsx = require('xlsx');
const { getDb, ensureUserDefaultCategories } = require('./db/database.cts');
const { previewSpreadsheet, applyImportDecisions } = require('./services/spreadsheetImportService.cts');
async function setup() {
  const db = getDb();
  db.prepare('INSERT INTO users (username,password_hash) VALUES (?,?)').run('importer','x');
  const userId = db.prepare('SELECT id FROM users WHERE username=?').get('importer').id;
  ensureUserDefaultCategories(userId);
  const categoryId = db.prepare('SELECT id FROM categories WHERE name=? AND user_id=?').get('Other', userId).id;
  const billId = db.prepare('INSERT INTO bills (user_id,name,category_id,due_day,expected_amount,active) VALUES (?,?,?,?,?,1)')
    .run(userId, 'Capital One', categoryId, 12, 80).lastInsertRowid;
  const wb = xlsx.utils.book_new();
  xlsx.utils.book_append_sheet(wb, xlsx.utils.aoa_to_sheet([
    ['Bill','Amount','Due Date','Paid Date','Notes'],
    ['Capital One','85.23','5/12/2026','5/13/2026','monthly note'],
    ['New Gym','25.00','5/20/2026','5/21/2026',''],
  ]), 'May 2026');
  const preview = await previewSpreadsheet(userId, xlsx.write(wb, { type: 'buffer', bookType: 'xlsx' }), { default_year: 2026 });
  return { db, userId, billId, preview };
}
`;

runApplyRegression(
  'match_existing_bill succeeds with numeric bill_id',
  `
${APPLY_SETUP}
(async () => {
  const { db, userId, billId, preview } = await setup();
  const row = preview.rows.find(r => r.detected_bill_name === 'Capital One');
  const result = await applyImportDecisions(userId, preview.import_session_id, [{
    row_id: row.row_id, action: 'match_existing_bill', bill_id: billId, year: 2026, month: 5,
    actual_amount: 85.23, notes: 'monthly note',
  }], {});
  assert.strictEqual(result.rows_created, 1);
  assert.strictEqual(result.rows_errored, 0);
  const state = db.prepare('SELECT * FROM monthly_bill_state WHERE bill_id=? AND year=2026 AND month=5').get(billId);
  assert.strictEqual(state.actual_amount, 85.23);
  assert.strictEqual(state.notes, 'monthly note');
  const bill = db.prepare('SELECT expected_amount, due_day FROM bills WHERE id=?').get(billId);
  assert.strictEqual(bill.expected_amount, 80);
  assert.strictEqual(bill.due_day, 12);
})().catch(err => { console.error(err.stack || err); process.exit(1); });
`,
);

runApplyRegression(
  'paid date column creates payment for matched bill',
  `
${APPLY_SETUP}
(async () => {
  const { db, userId, billId, preview } = await setup();
  const row = preview.rows.find(r => r.detected_bill_name === 'Capital One');
  assert.strictEqual(row.detected_paid_date, '2026-05-13');
  assert.strictEqual(row.detected_payment_amount, 85.23);
  const result = await applyImportDecisions(userId, preview.import_session_id, [{
    row_id: row.row_id,
    action: 'match_existing_bill',
    bill_id: billId,
    year: 2026,
    month: 5,
    actual_amount: 85.23,
    payment_amount: row.detected_payment_amount,
    payment_date: row.detected_paid_date,
  }], {});
  assert.strictEqual(result.rows_created, 1);
  assert.strictEqual(result.rows_errored, 0);
  assert.strictEqual(result.details[0].payment, 'created');
  const payment = db.prepare('SELECT amount, paid_date FROM payments WHERE bill_id=?').get(billId);
  assert.strictEqual(payment.amount, 85.23);
  assert.strictEqual(payment.paid_date, '2026-05-13');
})().catch(err => { console.error(err.stack || err); process.exit(1); });
`,
);

runApplyRegression(
  'paid date column creates payment for new bill',
  `
${APPLY_SETUP}
(async () => {
  const { db, userId, preview } = await setup();
  const row = preview.rows.find(r => r.detected_bill_name === 'New Gym');
  assert.strictEqual(row.detected_paid_date, '2026-05-21');
  const result = await applyImportDecisions(userId, preview.import_session_id, [{
    row_id: row.row_id,
    action: 'create_new_bill',
    bill_name: 'New Gym',
    due_day: 20,
    expected_amount: 25,
    actual_amount: 25,
    year: 2026,
    month: 5,
    payment_amount: row.detected_payment_amount,
    payment_date: row.detected_paid_date,
  }], {});
  assert.strictEqual(result.rows_created, 1);
  assert.strictEqual(result.rows_errored, 0);
  assert.strictEqual(result.details[0].payment, 'created');
  const bill = db.prepare('SELECT id FROM bills WHERE name=?').get('New Gym');
  const payment = db.prepare('SELECT amount, paid_date FROM payments WHERE bill_id=?').get(bill.id);
  assert.strictEqual(payment.amount, 25);
  assert.strictEqual(payment.paid_date, '2026-05-21');
})().catch(err => { console.error(err.stack || err); process.exit(1); });
`,
);

runApplyRegression(
  'create_new_bill imports related paid months for same detected bill',
  `
const assert = require('assert');
const xlsx = require('xlsx');
const { getDb } = require('./db/database.cts');
const { previewSpreadsheet, applyImportDecisions } = require('./services/spreadsheetImportService.cts');
(async () => {
  const db = getDb();
  db.prepare('INSERT INTO users (username,password_hash) VALUES (?,?)').run('importer','x');
  const userId = db.prepare('SELECT id FROM users WHERE username=?').get('importer').id;
  const wb = xlsx.utils.book_new();
  xlsx.utils.book_append_sheet(wb, xlsx.utils.aoa_to_sheet([
    ['Due Date','Bill','Amount','Paid Date'],
    ['4/1','Electric','156','4/2'],
  ]), 'April 2017');
  xlsx.utils.book_append_sheet(wb, xlsx.utils.aoa_to_sheet([
    ['Due Date','Bill','Amount','Paid Date'],
    ['5/1','Electric','183','4/28'],
  ]), 'May 2017');
  xlsx.utils.book_append_sheet(wb, xlsx.utils.aoa_to_sheet([
    ['Due Date','Bill','Amount','Paid Date'],
    ['5/1','Water','50','5/3'],
  ]), 'May 2017 Other');
  const preview = await previewSpreadsheet(userId, xlsx.write(wb, { type: 'buffer', bookType: 'xlsx' }), { parse_all_sheets: true });
  const row = preview.rows.find(r => r.sheet_name === 'April 2017' && r.detected_bill_name === 'Electric');
  const result = await applyImportDecisions(userId, preview.import_session_id, [{
    row_id: row.row_id,
    action: 'create_new_bill',
    bill_name: 'Electric',
    due_day: 1,
    expected_amount: 156,
    actual_amount: 156,
    year: 2017,
    month: 4,
    payment_amount: row.detected_payment_amount,
    payment_date: row.detected_paid_date,
  }], { reviewed_skipped_count: preview.rows.length - 1 });
  assert.strictEqual(result.rows_created, 2);
  assert.strictEqual(result.rows_skipped, 1);
  const createdDetail = result.details.find(d => d.action === 'create_new_bill');
  assert.strictEqual(createdDetail.related_months_imported, 1);
  const bill = db.prepare('SELECT id FROM bills WHERE name=?').get('Electric');
  const states = db.prepare('SELECT year, month, actual_amount FROM monthly_bill_state WHERE bill_id=? ORDER BY year, month').all(bill.id);
  assert.deepStrictEqual(states.map(s => [s.year, s.month, s.actual_amount]), [[2017, 4, 156], [2017, 5, 183]]);
  const payments = db.prepare('SELECT amount, paid_date FROM payments WHERE bill_id=? ORDER BY paid_date').all(bill.id);
  assert.deepStrictEqual(payments.map(p => [p.amount, p.paid_date]), [[156, '2017-04-02'], [183, '2017-04-28']]);
})().catch(err => { console.error(err.stack || err); process.exit(1); });
`,
);

runApplyRegression(
  'match_existing_bill succeeds with string bill_id',
  `
${APPLY_SETUP}
(async () => {
  const { db, userId, billId, preview } = await setup();
  const row = preview.rows.find(r => r.detected_bill_name === 'Capital One');
  const result = await applyImportDecisions(userId, preview.import_session_id, [{
    row_id: row.row_id, action: 'match_existing_bill', bill_id: String(billId), year: '2026', month: '5',
    actual_amount: 85.23,
  }], {});
  assert.strictEqual(result.rows_created, 1);
  assert.strictEqual(result.rows_errored, 0);
  const state = db.prepare('SELECT actual_amount FROM monthly_bill_state WHERE bill_id=?').get(billId);
  assert.strictEqual(state.actual_amount, 85.23);
})().catch(err => { console.error(err.stack || err); process.exit(1); });
`,
);

runApplyRegression(
  'match_existing_bill missing bill_id returns status 400',
  `
${APPLY_SETUP}
(async () => {
  const { userId, preview } = await setup();
  const row = preview.rows.find(r => r.detected_bill_name === 'Capital One');
  let err = null;
  try {
    await applyImportDecisions(userId, preview.import_session_id, [{ row_id: row.row_id, action: 'match_existing_bill', year: 2026, month: 5 }], {});
  } catch (e) { err = e; }
  assert.ok(err);
  assert.strictEqual(err.status, 400);
  assert.ok(err.message.includes('bill_id is required'));
})().catch(err => { console.error(err.stack || err); process.exit(1); });
`,
);

runApplyRegression(
  'match_existing_bill invalid bill_id returns clear error not crash',
  `
${APPLY_SETUP}
(async () => {
  const { userId, preview } = await setup();
  const row = preview.rows.find(r => r.detected_bill_name === 'Capital One');
  let err = null;
  try {
    await applyImportDecisions(userId, preview.import_session_id, [{ row_id: row.row_id, action: 'match_existing_bill', bill_id: 'abc', year: 2026, month: 5 }], {});
  } catch (e) { err = e; }
  assert.ok(err);
  assert.strictEqual(err.status, 400);
  assert.ok(err.message.includes('integer'));
})().catch(err => { console.error(err.stack || err); process.exit(1); });
`,
);

runApplyRegression(
  'unsupported action returns clear 400',
  `
${APPLY_SETUP}
(async () => {
  const { userId, preview } = await setup();
  const row = preview.rows.find(r => r.detected_bill_name === 'Capital One');
  let err = null;
  try {
    await applyImportDecisions(userId, preview.import_session_id, [{ row_id: row.row_id, action: 'teleport_bill' }], {});
  } catch (e) { err = e; }
  assert.ok(err);
  assert.strictEqual(err.status, 400);
  assert.strictEqual(err.code, 'IMPORT_VALIDATION_ERROR');
  assert.strictEqual(err.details[0].field, 'action');
})().catch(err => { console.error(err.stack || err); process.exit(1); });
`,
);

runApplyRegression(
  'unknown row_id returns clear 400',
  `
${APPLY_SETUP}
(async () => {
  const { userId, preview, billId } = await setup();
  let err = null;
  try {
    await applyImportDecisions(userId, preview.import_session_id, [{ row_id: 'row_9999', action: 'match_existing_bill', bill_id: billId, year: 2026, month: 5 }], {});
  } catch (e) { err = e; }
  assert.ok(err);
  assert.strictEqual(err.status, 400);
  assert.strictEqual(err.details[0].field, 'row_id');
})().catch(err => { console.error(err.stack || err); process.exit(1); });
`,
);

runApplyRegression(
  'create_new_bill without bill_name returns clear 400',
  `
${APPLY_SETUP}
(async () => {
  const { userId, preview } = await setup();
  const row = preview.rows.find(r => r.detected_bill_name === 'New Gym');
  let err = null;
  try {
    await applyImportDecisions(userId, preview.import_session_id, [{ row_id: row.row_id, action: 'create_new_bill', year: 2026, month: 5 }], {});
  } catch (e) { err = e; }
  assert.ok(err);
  assert.strictEqual(err.status, 400);
  assert.strictEqual(err.details[0].field, 'bill_name');
})().catch(err => { console.error(err.stack || err); process.exit(1); });
`,
);

runApplyRegression(
  'invalid year and month return clear 400',
  `
${APPLY_SETUP}
(async () => {
  const { userId, preview, billId } = await setup();
  const row = preview.rows.find(r => r.detected_bill_name === 'Capital One');
  let err = null;
  try {
    await applyImportDecisions(userId, preview.import_session_id, [{ row_id: row.row_id, action: 'match_existing_bill', bill_id: billId, year: 3026, month: 99 }], {});
  } catch (e) { err = e; }
  assert.ok(err);
  assert.strictEqual(err.status, 400);
  assert.ok(['year','month'].includes(err.details[0].field));
})().catch(err => { console.error(err.stack || err); process.exit(1); });
`,
);

runApplyRegression(
  'bulk-style create_new_bill without category_id does not crash',
  `
${APPLY_SETUP}
(async () => {
  const { db, userId, preview } = await setup();
  const row = preview.rows.find(r => r.detected_bill_name === 'New Gym');
  const result = await applyImportDecisions(userId, preview.import_session_id, [{
    row_id: row.row_id,
    action: 'create_new_bill',
    bill_name: 'New Gym',
    due_day: 20,
    expected_amount: 25,
    actual_amount: 25,
    year: 2026,
    month: 5,
    notes: null,
  }], {});
  assert.strictEqual(result.rows_created, 1);
  assert.strictEqual(result.rows_errored, 0);
  assert.ok(db.prepare('SELECT id FROM bills WHERE name=?').get('New Gym'));
})().catch(err => { console.error(err.stack || err); process.exit(1); });
`,
);

runApplyRegression(
  'skip_row requires no bill_id year or month',
  `
${APPLY_SETUP}
(async () => {
  const { userId, preview } = await setup();
  const row = preview.rows.find(r => r.detected_bill_name === 'Capital One');
  const result = await applyImportDecisions(userId, preview.import_session_id, [{ row_id: row.row_id, action: 'skip_row' }], {});
  assert.strictEqual(result.rows_skipped, 1);
  assert.strictEqual(result.rows_errored, 0);
})().catch(err => { console.error(err.stack || err); process.exit(1); });
`,
);

runApplyRegression(
  'omitted reviewed skip rows are recorded in summary and history',
  `
${APPLY_SETUP}
(async () => {
  const { db, userId, preview } = await setup();
  const row = preview.rows.find(r => r.detected_bill_name === 'New Gym');
  const result = await applyImportDecisions(userId, preview.import_session_id, [{
    row_id: row.row_id,
    action: 'create_new_bill',
    bill_name: 'New Gym',
    due_day: 20,
    expected_amount: 25,
    actual_amount: 25,
    year: 2026,
    month: 5,
  }], { reviewed_skipped_count: 1 });
  assert.strictEqual(result.rows_created, 1);
  assert.strictEqual(result.rows_skipped, 1);
  const hist = db.prepare('SELECT rows_skipped FROM import_history ORDER BY id DESC LIMIT 1').get();
  assert.strictEqual(hist.rows_skipped, 1);
})().catch(err => { console.error(err.stack || err); process.exit(1); });
`,
);

runApplyRegression(
  'match_existing_bill nonexistent bill_id is row error not 500',
  `
${APPLY_SETUP}
(async () => {
  const { userId, preview } = await setup();
  const row = preview.rows.find(r => r.detected_bill_name === 'Capital One');
  const result = await applyImportDecisions(userId, preview.import_session_id, [{
    row_id: row.row_id, action: 'match_existing_bill', bill_id: 99999, year: 2026, month: 5,
  }], {});
  assert.strictEqual(result.rows_errored, 1);
  assert.ok(result.details[0].error.includes('not found or inactive'));
})().catch(err => { console.error(err.stack || err); process.exit(1); });
`,
);

runApplyRegression(
  'create_new_bill and skip_row still work',
  `
${APPLY_SETUP}
(async () => {
  const { db, userId, preview } = await setup();
  const newRow = preview.rows.find(r => r.detected_bill_name === 'New Gym');
  const matchRow = preview.rows.find(r => r.detected_bill_name === 'Capital One');
  const result = await applyImportDecisions(userId, preview.import_session_id, [
    { row_id: newRow.row_id, action: 'create_new_bill', bill_name: 'New Gym', due_day: 20, expected_amount: 25, actual_amount: 25, year: 2026, month: 5 },
    { row_id: matchRow.row_id, action: 'skip_row' },
  ], {});
  assert.strictEqual(result.rows_created, 1);
  assert.strictEqual(result.rows_skipped, 1);
  assert.ok(db.prepare('SELECT id FROM bills WHERE name=?').get('New Gym'));
})().catch(err => { console.error(err.stack || err); process.exit(1); });
`,
);

console.log('\n── user SQLite import regression ────────────────────────────────');

const USER_DB_SETUP = `
const assert = require('assert');
const fs = require('fs');
const path = require('path');
const Database = require('better-sqlite3');
const { getDb, ensureUserDefaultCategories } = require('./db/database.cts');
const { previewUserDbImport, applyUserDbImport } = require('./services/userDbImportService.cts');

function createExportBuffer(nameSuffix = '') {
  const file = path.join('/tmp', 'bill-tracker-user-export-test-' + process.pid + '-' + Date.now() + nameSuffix + '.sqlite');
  const out = new Database(file);
  out.exec(\`
    CREATE TABLE export_metadata (key TEXT PRIMARY KEY, value TEXT);
    CREATE TABLE categories (id INTEGER PRIMARY KEY, name TEXT, created_at TEXT, updated_at TEXT);
    CREATE TABLE bills (id INTEGER PRIMARY KEY, name TEXT, category_id INTEGER, due_day INTEGER, override_due_date TEXT, bucket TEXT, expected_amount REAL, interest_rate REAL, billing_cycle TEXT, autopay_enabled INTEGER, autodraft_status TEXT, website TEXT, username TEXT, account_info TEXT, has_2fa INTEGER, active INTEGER, notes TEXT, created_at TEXT, updated_at TEXT);
    CREATE TABLE payments (id INTEGER PRIMARY KEY, bill_id INTEGER, amount REAL, paid_date TEXT, method TEXT, notes TEXT, created_at TEXT, updated_at TEXT);
    CREATE TABLE monthly_bill_state (id INTEGER PRIMARY KEY, bill_id INTEGER, year INTEGER, month INTEGER, actual_amount REAL, notes TEXT, is_skipped INTEGER, created_at TEXT, updated_at TEXT);
    CREATE TABLE notes (type TEXT, bill_id INTEGER, payment_id INTEGER, monthly_state_id INTEGER, year INTEGER, month INTEGER, notes TEXT);
  \`);
  out.prepare('INSERT INTO export_metadata (key, value) VALUES (?, ?)').run('metadata_json', JSON.stringify({ export_type: 'user_data', exported_at: '2026-05-03T00:00:00.000Z', includes: ['Bills','Payments','Categories','Monthly bill state','Notes','Export metadata'] }));
  out.prepare('INSERT INTO categories (id, name) VALUES (?, ?)').run(10, 'Imported Utilities');
  out.prepare('INSERT INTO bills (id, name, category_id, due_day, expected_amount, interest_rate, billing_cycle, active, notes) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)').run(20, 'Electric', 10, 15, 156, 29.99, 'monthly', 1, 'bill note');
  out.prepare('INSERT INTO payments (id, bill_id, amount, paid_date, method, notes) VALUES (?, ?, ?, ?, ?, ?)').run(30, 20, 156, '2026-05-15', 'card', 'paid');
  out.prepare('INSERT INTO monthly_bill_state (id, bill_id, year, month, actual_amount, notes, is_skipped) VALUES (?, ?, ?, ?, ?, ?, ?)').run(40, 20, 2026, 5, 156, 'monthly', 0);
  out.close();
  const buffer = fs.readFileSync(file);
  fs.unlinkSync(file);
  return buffer;
}

function setupUser() {
  const db = getDb();
  db.prepare('INSERT INTO users (username,password_hash) VALUES (?,?)').run('sqlite-importer','x');
  const userId = db.prepare('SELECT id FROM users WHERE username=?').get('sqlite-importer').id;
  ensureUserDefaultCategories(userId);
  return { db, userId };
}
`;

runApplyRegression(
  'user SQLite preview reads app user export and writes no live data',
  `
${USER_DB_SETUP}
(async () => {
  const { db, userId } = setupUser();
  const beforeBills = db.prepare('SELECT COUNT(*) AS n FROM bills WHERE user_id=?').get(userId).n;
  const preview = await previewUserDbImport(userId, createExportBuffer(), { original_filename: 'user-export.sqlite' });
  assert.strictEqual(preview.import_type, 'user_db');
  assert.strictEqual(preview.counts.bills, 1);
  assert.strictEqual(preview.counts.payments, 1);
  assert.strictEqual(preview.summary.bills.create, 1);
  const afterBills = db.prepare('SELECT COUNT(*) AS n FROM bills WHERE user_id=?').get(userId).n;
  assert.strictEqual(afterBills, beforeBills);
})().catch(err => { console.error(err.stack || err); process.exit(1); });
`,
);

runApplyRegression(
  'user SQLite apply imports signed-in user data and records history',
  `
${USER_DB_SETUP}
(async () => {
  const { db, userId } = setupUser();
  const preview = await previewUserDbImport(userId, createExportBuffer('-apply'), { original_filename: 'user-export.sqlite' });
  const result = await applyUserDbImport(userId, preview.import_session_id, {});
  assert.strictEqual(result.rows_errored, 0);
  assert.ok(result.rows_created >= 4);
  const bill = db.prepare('SELECT * FROM bills WHERE user_id=? AND name=?').get(userId, 'Electric');
  assert.ok(bill);
  assert.strictEqual(bill.interest_rate, 29.99);
  assert.ok(db.prepare('SELECT id FROM payments WHERE bill_id=? AND amount=?').get(bill.id, 156));
  assert.ok(db.prepare('SELECT id FROM monthly_bill_state WHERE bill_id=? AND year=2026 AND month=5').get(bill.id));
  const hist = db.prepare("SELECT file_type, rows_created FROM import_history WHERE user_id=? ORDER BY id DESC LIMIT 1").get(userId);
  assert.strictEqual(hist.file_type, 'sqlite');
  assert.ok(hist.rows_created >= 4);
})().catch(err => { console.error(err.stack || err); process.exit(1); });
`,
);

runApplyRegression(
  'user SQLite conflicts are skipped by default',
  `
${USER_DB_SETUP}
(async () => {
  const { db, userId } = setupUser();
  const preview1 = await previewUserDbImport(userId, createExportBuffer('-one'), {});
  await applyUserDbImport(userId, preview1.import_session_id, {});
  const preview2 = await previewUserDbImport(userId, createExportBuffer('-two'), {});
  const result = await applyUserDbImport(userId, preview2.import_session_id, {});
  assert.strictEqual(result.rows_errored, 0);
  assert.ok(result.rows_conflicted > 0);
  assert.strictEqual(db.prepare('SELECT COUNT(*) AS n FROM bills WHERE user_id=? AND name=?').get(userId, 'Electric').n, 1);
})().catch(err => { console.error(err.stack || err); process.exit(1); });
`,
);

runApplyRegression(
  'user SQLite invalid file is rejected safely',
  `
${USER_DB_SETUP}
(async () => {
  const { userId } = setupUser();
  try {
    await previewUserDbImport(userId, Buffer.from('not sqlite'), {});
    assert.fail('expected invalid sqlite rejection');
  } catch (err) {
    assert.strictEqual(err.status, 400);
    assert.strictEqual(err.code, 'USER_DB_IMPORT_INVALID_SQLITE');
  }
})().catch(err => { console.error(err.stack || err); process.exit(1); });
`,
);

runApplyRegression(
  'user SQLite full app backup shape is rejected safely',
  `
${USER_DB_SETUP}
(async () => {
  const { userId } = setupUser();
  const file = '/tmp/bill-tracker-full-backup-shape-' + process.pid + '.sqlite';
  try { fs.unlinkSync(file); } catch {}
  const out = new Database(file);
  out.exec('CREATE TABLE users (id INTEGER PRIMARY KEY, username TEXT, password_hash TEXT); CREATE TABLE sessions (id TEXT PRIMARY KEY, user_id INTEGER);');
  out.close();
  const buffer = fs.readFileSync(file);
  fs.unlinkSync(file);
  try {
    await previewUserDbImport(userId, buffer, {});
    assert.fail('expected full app backup shape rejection');
  } catch (err) {
    assert.strictEqual(err.status, 400);
    assert.ok(['USER_DB_IMPORT_UNSUPPORTED_SCHEMA', 'USER_DB_IMPORT_NOT_USER_EXPORT'].includes(err.code));
  }
})().catch(err => { console.error(err.stack || err); process.exit(1); });
`,
);

// ─── Save fixtures ────────────────────────────────────────────────────────────
const singlePath = path.join(__dirname, 'test-import-fixture.xlsx');
const multiPath = path.join(__dirname, 'test-import-multi-fixture.xlsx');
fs.writeFileSync(singlePath, createSingleSheetXlsx());
fs.writeFileSync(multiPath, createMultiSheetXlsx());

console.log(`\n── Fixture files ────────────────────────────────────────────────`);
console.log(`  Single-sheet: ${singlePath}`);
console.log(`  Multi-sheet:  ${multiPath}`);
console.log(`\n  Test with curl (requires running server + valid session cookie):`);
console.log(`  # Single sheet:`);
console.log(`  curl -b bt_session=<session> -X POST \\`);
console.log(`    http://localhost:3000/api/import/spreadsheet/preview \\`);
console.log(`    -H 'Content-Type: application/octet-stream' \\`);
console.log(`    --data-binary @${singlePath}`);
console.log(`  # All sheets:`);
console.log(`  curl -b bt_session=<session> -X POST \\`);
console.log(
  `    'http://localhost:3000/api/import/spreadsheet/preview?parse_all_sheets=true&year=2026' \\`,
);
console.log(`    -H 'Content-Type: application/octet-stream' \\`);
console.log(`    --data-binary @${multiPath}`);

console.log(`\n─────────────────────────────────────────────────────────────────`);
console.log(`  ${passed} passed, ${failed} failed\n`);
if (failed > 0) process.exit(1);