// Run: node research/offset-ledger/verify-importer.mjs
// Expected rows are specified independently of the parser. The calendar oracle
// uses native UTC round trips rather than the importer's month/leap arithmetic.
import assert from 'node:assert/strict';
import {
  parseDailyCsv, dailyCsv, CsvImportError, CSV_COLUMNS, CSV_LIMITS,
} from '../../public/tools/offset-ledger/importer.mjs';

const HEADER = 'date,loan,offset,annualRatePercent';
const row = (date = '2026-01-01', loan = '100000.00', offset = '10000.00', annualRatePercent = '5.25') =>
  ({ date, loan, offset, annualRatePercent });
const LINE = '2026-01-01,100000.00,10000.00,5.25';
let fixtures = 0;
let rejectedInputs = 0;
let calendarCases = 0;
let spellingCases = 0;

function test(label, check) {
  try { check(); } catch (error) {
    error.message = `${label}: ${error.message}`;
    throw error;
  }
  fixtures += 1;
}

function rejects(action, code, line, field) {
  assert.throws(action, error => {
    assert.ok(error instanceof CsvImportError, 'must return an actionable typed input error');
    assert.equal(error.code, code);
    if (line !== undefined) assert.equal(error.line, line);
    if (field !== undefined) assert.equal(error.field, field);
    assert.ok(error.message.includes(`Line ${error.line}`));
    return true;
  });
  rejectedInputs += 1;
}

function bad(label, text, code, line, field) {
  test(label, () => rejects(() => parseDailyCsv(text), code, line, field));
}

test('declared schema and limits', () => {
  assert.deepEqual(CSV_COLUMNS, ['date', 'loan', 'offset', 'annualRatePercent']);
  assert.deepEqual(CSV_LIMITS, { maxBytes: 4194304, maxRows: 3660, maxFieldChars: 32, maxFractionDigits: 12 });
});
test('plain CSV without final newline', () => assert.deepEqual(parseDailyCsv(`${HEADER}\n${LINE}`), [row()]));
test('UTF-8 BOM, quoted header and fields, CRLF', () => {
  const csv = '\uFEFF"date","loan","offset","annualRatePercent"\r\n"2026-01-01","100000.00","10000.00","5.25"\r\n';
  assert.deepEqual(parseDailyCsv(csv), [row()]);
});
test('mixed LF and CRLF unambiguous record endings', () => {
  assert.deepEqual(parseDailyCsv(`${HEADER}\r\n${LINE}\n2026-01-02,0,0,0\r\n`), [row(), row('2026-01-02', '0', '0', '0')]);
});
test('only genuinely empty trailing lines disappear', () => {
  assert.deepEqual(parseDailyCsv(`${HEADER}\n${LINE}\n\n\r\n\n`), [row()]);
});
test('zero values and offset above loan are allowed', () => {
  assert.deepEqual(parseDailyCsv(`${HEADER}\n2026-01-01,0,100,0`), [row('2026-01-01', '0', '100', '0')]);
});
test('retain precision beyond binary floating point', () => {
  const expected = row('2026-01-01', '9007199254740993.123456789012', '000000.2500', '0.000000000001');
  assert.deepEqual(parseDailyCsv(`${HEADER}\n2026-01-01,9007199254740993.123456789012,000000.2500,0.000000000001`), [expected]);
});
test('do not reorder, fill or interpolate missing calendar days', () => {
  assert.deepEqual(parseDailyCsv(`${HEADER}\n2026-01-03,3,2,1\n2026-01-01,9,8,7`), [row('2026-01-03', '3', '2', '1'), row('2026-01-01', '9', '8', '7')]);
});
test('date domain endpoints', () => {
  assert.deepEqual(parseDailyCsv(`${HEADER}\n0001-01-01,1,0,1\n9999-12-31,1,0,1`), [row('0001-01-01', '1', '0', '1'), row('9999-12-31', '1', '0', '1')]);
});

bad('nontext input', null, 'INVALID_TEXT', 1);
bad('empty file', '', 'EMPTY_CSV', 1);
bad('BOM alone', '\uFEFF', 'EMPTY_CSV', 1);
bad('no daily data', `${HEADER}\n\n`, 'NO_DATA_ROWS', 2);
bad('blank leading line', `\n${HEADER}\n${LINE}`, 'EMPTY_HEADER', 1, 'header');
bad('duplicate header', `date,loan,loan,annualRatePercent\n${LINE}`, 'DUPLICATE_HEADER', 1, 'header');
bad('unknown header', `date,loan,balance,annualRatePercent\n${LINE}`, 'UNKNOWN_HEADER', 1, 'header');
bad('reordered header', `date,offset,loan,annualRatePercent\n${LINE}`, 'HEADER_ORDER', 1, 'header');
bad('missing header column', `date,loan,offset\n${LINE}`, 'COLUMN_COUNT', 1, 'annualRatePercent');
bad('extra header column', `${HEADER},memo\n${LINE}`, 'COLUMN_COUNT', 1, 'column 5');
bad('header whitespace is not silently trimmed', `date, loan,offset,annualRatePercent\n${LINE}`, 'UNKNOWN_HEADER', 1, 'header');
bad('header case is exact', `Date,loan,offset,annualRatePercent\n${LINE}`, 'UNKNOWN_HEADER', 1, 'header');
bad('BOM is only valid at file start', `${HEADER}\n\uFEFF${LINE}`, 'INVALID_DATE', 2, 'date');
bad('data without header', LINE, 'UNKNOWN_HEADER', 1, 'header');
bad('internal blank line', `${HEADER}\n${LINE}\n\n2026-01-02,1,0,1`, 'BLANK_RECORD', 3);
bad('blank line before first daily row', `${HEADER}\n\n${LINE}`, 'BLANK_RECORD', 2);
bad('trailing spaces are not an empty physical line', `${HEADER}\n${LINE}\n `, 'COLUMN_COUNT', 3, 'loan');
bad('trailing quoted empty field is not an empty physical line', `${HEADER}\n${LINE}\n""`, 'COLUMN_COUNT', 3, 'loan');
bad('trailing delimiter row is not an empty physical line', `${HEADER}\n${LINE}\n,,,`, 'EMPTY_FIELD', 3, 'date');
bad('missing data column', `${HEADER}\n2026-01-01,1,0`, 'COLUMN_COUNT', 2, 'annualRatePercent');
bad('empty final data field', `${HEADER}\n2026-01-01,1,0,`, 'EMPTY_FIELD', 2, 'annualRatePercent');
bad('empty middle data field', `${HEADER}\n2026-01-01,,0,5`, 'EMPTY_FIELD', 2, 'loan');
bad('empty quoted field', `${HEADER}\n2026-01-01,1,"",5`, 'EMPTY_FIELD', 2, 'offset');
bad('trailing extra empty column', `${HEADER}\n${LINE},`, 'COLUMN_COUNT', 2, 'column 5');
bad('trailing extra quoted column', `${HEADER}\n${LINE},"memo"`, 'COLUMN_COUNT', 2, 'column 5');
bad('duplicate dates even with different values', `${HEADER}\n${LINE}\n2026-01-01,8,7,6`, 'DUPLICATE_DATE', 3, 'date');
test('duplicate date names original line', () => {
  try { parseDailyCsv(`${HEADER}\r\n${LINE}\r\n2026-01-01,1,0,1`); } catch (error) {
    assert.equal(error.details.firstLine, 2);
    assert.equal(error.details.date, '2026-01-01');
    return;
  }
  assert.fail('duplicate must fail');
});

bad('unclosed quote at EOF', `${HEADER}\n2026-01-01,"1,0,5`, 'UNCLOSED_QUOTE', 2, 'loan');
bad('unclosed quote before newline remains unclosed', `${HEADER}\n2026-01-01,"1,0,5\n`, 'UNCLOSED_QUOTE', 2, 'loan');
bad('quote inside unquoted field', `${HEADER}\n2026-01-01,1"2,0,5`, 'UNEXPECTED_QUOTE', 2, 'loan');
bad('characters after closing quote', `${HEADER}\n2026-01-01,"1"2,0,5`, 'TEXT_AFTER_QUOTE', 2, 'loan');
bad('whitespace after closing quote', `${HEADER}\n2026-01-01,"1" ,0,5`, 'TEXT_AFTER_QUOTE', 2, 'loan');
bad('escaped quote is parsed then rejected as decimal data', `${HEADER}\n2026-01-01,"1""2",0,5`, 'INVALID_DECIMAL', 2, 'loan');
bad('quoted comma is parsed then rejected as locale number', `${HEADER}\n2026-01-01,"1,000",0,5`, 'INVALID_DECIMAL', 2, 'loan');
bad('quoted LF is not silently joined', `${HEADER}\n2026-01-01,"1\n2",0,5`, 'INVALID_DECIMAL', 2, 'loan');
bad('quoted CRLF is not silently joined', `${HEADER}\r\n2026-01-01,"1\r\n2",0,5`, 'INVALID_DECIMAL', 2, 'loan');
bad('NUL in a data field', `${HEADER}\r\n2026-01-01,1,0,5\0`, 'BINARY_NUL', 2, 'annualRatePercent');
bad('NUL in quoted data', `${HEADER}\n2026-01-01,"1\0",0,5`, 'BINARY_NUL', 2, 'loan');
bad('isolated carriage return', `${HEADER}\r${LINE}`, 'BARE_CR', 1, 'header');
bad('tabs do not become commas', `date\tloan\toffset\tannualRatePercent\n${LINE}`, 'CONTROL_CHARACTER', 1, 'header');
bad('control character in numeric field', `${HEADER}\n2026-01-01,1\u0001,0,5`, 'CONTROL_CHARACTER', 2, 'loan');
bad('UTF-16-looking NUL pattern', `d\0a\0t\0e\0`, 'BINARY_NUL', 1, 'header');

for (const [name, value, code] of [
  ['negative', '-1', 'UNSAFE_SPREADSHEET_VALUE'],
  ['negative zero', '-0', 'UNSAFE_SPREADSHEET_VALUE'],
  ['plus prefix', '+1', 'UNSAFE_SPREADSHEET_VALUE'],
  ['formula', '=1+2', 'UNSAFE_SPREADSHEET_VALUE'],
  ['function formula', '@SUM(1)', 'UNSAFE_SPREADSHEET_VALUE'],
  ['spaced formula', ' =1+2', 'UNSAFE_SPREADSHEET_VALUE'],
  ['scientific notation', '1e5', 'INVALID_DECIMAL'],
  ['NaN', 'NaN', 'INVALID_DECIMAL'],
  ['Infinity', 'Infinity', 'INVALID_DECIMAL'],
  ['leading whitespace', ' 1', 'INVALID_DECIMAL'],
  ['trailing whitespace', '1 ', 'INVALID_DECIMAL'],
  ['currency symbol', '$1', 'INVALID_DECIMAL'],
  ['spreadsheet text marker', "'1", 'INVALID_DECIMAL'],
  ['decimal without whole digits', '.5', 'INVALID_DECIMAL'],
  ['decimal without fractional digits', '1.', 'INVALID_DECIMAL'],
  ['hexadecimal', '0x10', 'INVALID_DECIMAL'],
  ['Unicode digits', '１２３', 'INVALID_DECIMAL'],
  ['percent sign', '5%', 'INVALID_DECIMAL'],
]) {
  for (const field of ['loan', 'offset', 'annualRatePercent']) {
    const values = ['2026-01-01', '1', '0', '5'];
    values[CSV_COLUMNS.indexOf(field)] = value;
    bad(`${name} in ${field}`, `${HEADER}\n${values.join(',')}`, code, 2, field);
  }
}
for (const value of ['2026-02-29', '1900-02-29', '2100-02-29', '2026-04-31', '2026-00-01', '2026-13-01', '2026-01-00', '2026-01-32', '0000-01-01', '10000-01-01', '01/02/2026', '2026-1-01', '2026-01-1', '2026-01-01T00:00:00Z', ' 2026-01-01']) {
  bad(`invalid date ${value}`, `${HEADER}\n${value},1,0,5`, 'INVALID_DATE', 2, 'date');
}
bad('formula date', `${HEADER}\n=DATE(2026),1,0,5`, 'UNSAFE_SPREADSHEET_VALUE', 2, 'date');

test('independent UTC calendar oracle across a complete Gregorian cycle', () => {
  for (let year = 1800; year < 2200; year += 1) {
    for (let month = 1; month <= 12; month += 1) {
      for (const day of [0, 28, 29, 30, 31, 32]) {
        const date = `${year}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
        const reference = new Date(0);
        reference.setUTCFullYear(year, month - 1, day);
        reference.setUTCHours(0, 0, 0, 0);
        const real = reference.getUTCFullYear() === year && reference.getUTCMonth() === month - 1 && reference.getUTCDate() === day;
        if (real) assert.equal(parseDailyCsv(`${HEADER}\n${date},1,0,1`)[0].date, date);
        else assert.throws(() => parseDailyCsv(`${HEADER}\n${date},1,0,1`), error => error instanceof CsvImportError && error.code === 'INVALID_DATE');
        calendarCases += 1;
      }
    }
  }
});

test('export matches independently written CSV bytes', () => {
  const rows = [row(), row('2026-01-02', '000001.2300', '0.000', '0.05000')];
  const before = JSON.stringify(rows);
  assert.equal(dailyCsv(rows), `${HEADER}\r\n${LINE}\r\n2026-01-02,000001.2300,0.000,0.05000\r\n`);
  assert.equal(JSON.stringify(rows), before, 'export does not mutate input');
  assert.deepEqual(parseDailyCsv(dailyCsv(rows)), rows);
});
test('generated decimal spellings survive quoted imports and exports', () => {
  // Fixed expected strings, not a numeric round trip through either engine.
  for (let integer = 0; integer < 100; integer += 1) {
    for (const digits of ['0', '00', '000001', '125000000001']) {
      const expected = row('2026-01-01', `000${integer}.${digits}`, `${integer}.00`, `0.${digits}`);
      const text = `"date","loan","offset","annualRatePercent"\r\n"2026-01-01","${expected.loan}","${expected.offset}","${expected.annualRatePercent}"\r\n`;
      assert.deepEqual(parseDailyCsv(text), [expected]);
      assert.equal(dailyCsv([expected]), `${HEADER}\r\n2026-01-01,${expected.loan},${expected.offset},${expected.annualRatePercent}\r\n`);
      spellingCases += 1;
    }
  }
});
test('export rejects sparse rows', () => rejects(() => dailyCsv(new Array(1)), 'INVALID_ROW', 2));
test('export rejects numeric monetary input', () => rejects(() => dailyCsv([row('2026-01-01', 123)]), 'INVALID_FIELD_TYPE', 2, 'loan'));
test('export rejects unknown row field', () => rejects(() => dailyCsv([{ ...row(), memo: 'secret' }]), 'UNKNOWN_FIELD', 2, 'memo'));
test('export rejects missing row field', () => rejects(() => dailyCsv([{ date: '2026-01-01', loan: '1', offset: '0' }]), 'MISSING_FIELD', 2, 'annualRatePercent'));
test('export rejects inherited field instead of silently using it', () => {
  const value = Object.assign(Object.create({ annualRatePercent: '5' }), { date: '2026-01-01', loan: '1', offset: '0' });
  rejects(() => dailyCsv([value]), 'MISSING_FIELD', 2, 'annualRatePercent');
});
test('export rejects duplicate dates', () => rejects(() => dailyCsv([row(), row()]), 'DUPLICATE_DATE', 3, 'date'));
test('export rejects formula injection', () => rejects(() => dailyCsv([row('2026-01-01', '=HYPERLINK("//example.test")')]), 'UNSAFE_SPREADSHEET_VALUE', 2, 'loan'));
test('export rejects multiline data', () => rejects(() => dailyCsv([row('2026-01-01', '1\n2')]), 'INVALID_DECIMAL', 2, 'loan'));
test('export rejects wrong rows type', () => rejects(() => dailyCsv({}), 'INVALID_ROWS', 1));
test('export rejects empty set', () => rejects(() => dailyCsv([]), 'NO_DATA_ROWS', 2));

test('field character boundary', () => {
  const accepted = '1'.repeat(32);
  assert.equal(parseDailyCsv(`${HEADER}\n2026-01-01,${accepted},0,0`)[0].loan, accepted);
  rejects(() => parseDailyCsv(`${HEADER}\n2026-01-01,${accepted}1,0,0`), 'FIELD_TOO_LONG', 2, 'loan');
  rejects(() => dailyCsv([row('2026-01-01', `${accepted}1`)]), 'FIELD_TOO_LONG', 2, 'loan');
});
test('fractional precision boundary is exact and enforced for every amount', () => {
  const twelve = '0.123456789012';
  const thirteen = '0.1234567890123';
  assert.deepEqual(parseDailyCsv(`${HEADER}\n2026-01-01,${twelve},${twelve},${twelve}`), [row('2026-01-01', twelve, twelve, twelve)]);
  for (const field of ['loan', 'offset', 'annualRatePercent']) {
    const values = ['2026-01-01', '1', '0', '5'];
    values[CSV_COLUMNS.indexOf(field)] = thirteen;
    rejects(() => parseDailyCsv(`${HEADER}\n${values.join(',')}`), 'TOO_MANY_FRACTION_DIGITS', 2, field);
    rejects(() => dailyCsv([{ ...row(), [field]: thirteen }]), 'TOO_MANY_FRACTION_DIGITS', 2, field);
  }
});
test('byte limit includes UTF-8 multibyte characters', () => {
  rejects(() => parseDailyCsv('a'.repeat(CSV_LIMITS.maxBytes + 1)), 'FILE_TOO_LARGE', 1);
  rejects(() => parseDailyCsv('€'.repeat(Math.floor(CSV_LIMITS.maxBytes / 3) + 1)), 'FILE_TOO_LARGE', 1);
});
test('many empty trailing lines do not count as records', () => {
  assert.deepEqual(parseDailyCsv(`${HEADER}\n${LINE}\n${'\n'.repeat(50000)}`), [row()]);
});
test('inclusive import and export row limit', () => {
  const records = Array.from({ length: CSV_LIMITS.maxRows + 1 }, (_, index) => {
    const date = new Date(Date.UTC(2020, 0, 1) + index * 86400000).toISOString().slice(0, 10);
    return row(date, '0', '0', '0');
  });
  const allowed = records.slice(0, CSV_LIMITS.maxRows);
  const output = dailyCsv(allowed);
  assert.equal(parseDailyCsv(output).length, CSV_LIMITS.maxRows);
  rejects(() => parseDailyCsv(`${output}${records.at(-1).date},0,0,0\r\n`), 'TOO_MANY_ROWS', CSV_LIMITS.maxRows + 2);
  rejects(() => dailyCsv(records), 'TOO_MANY_ROWS', CSV_LIMITS.maxRows + 2);
});
test('exact byte boundary includes the three-byte BOM', () => {
  const prefix = `\uFEFF${HEADER}\n${LINE}\n`;
  const file = prefix + '\n'.repeat(CSV_LIMITS.maxBytes - new TextEncoder().encode(prefix).byteLength);
  assert.deepEqual(parseDailyCsv(file), [row()]);
  rejects(() => parseDailyCsv(`${file}\n`), 'FILE_TOO_LARGE', 1);
});

console.log(JSON.stringify({ ok: true, fixtures, rejectedInputs, calendarCases, spellingCases }, null, 2));
