import assert from 'node:assert/strict';
import test from 'node:test';
import ExcelJS from 'exceljs';
import JSZip from 'jszip';
import { parseProgramInput } from '../src/program-parser.js';
import {
  PassengerRosterWorkbookError,
  normalizePassengerRosterWorkbook
} from '../src/passenger-roster-workbook.js';

const SOURCE_HEADERS = [
  '序号', '姓名', '英文姓名', '性别', '身份证号码', '出生日期', '年龄', '出生地',
  '护照号码', '签发地', '签发日期', '有效期', '电话', '备注'
] as const;

const ERP_HEADERS = [
  '序号', '姓名', 'NAME', '性别', '出生日期', '出生地', '证件类型', '证件号码',
  '签发地', '签发日', '有效期', '电话', '备注'
] as const;

const CANONICAL_HEADER = '序号\t姓名\tNAME\t性别\t出生日期\t出生地\t证件类型\t证件号码\t签发地\t签发日\t有效期\t电话\t备注';
const REORDERED_SOURCE_INDEXES = [8, 1, 13, 0, 10, 4, 6, 12, 3, 11, 5, 9, 2, 7];
const ATTACHMENT_VARIANT_INDEXES = [0, 1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 4];

type WorkbookMutation = (workbook: ExcelJS.Workbook) => void | Promise<void>;

const genderTemplate = (ref: string): string => `IF(OR(LEN(${ref})=15,LEN(${ref})=18),IF(MOD(MID(${ref},15,3)*1,2),"男","女"),NA())`;
const birthTemplate = (ref: string): string => `DATE(MID(${ref},7,VLOOKUP(LEN(${ref}),{15,2;18,4},2,0)),MID(${ref},VLOOKUP(LEN(${ref}),{15,9;18,11},2,0),2),MID(${ref},VLOOKUP(LEN(${ref}),{15,11;18,13},2,0),2))`;
const SYNTHETIC_ID = '11111119900102001X';
const normalizeSynthetic = (content: Buffer) => normalizePassengerRosterWorkbook({
  content, fileName: 'synthetic.xlsx', contentType: 'application/octet-stream'
});
const identityFormulas: WorkbookMutation = workbook => {
  const sheet = workbook.getWorksheet('Sheet1')!;
  sheet.getCell('E3').value = SYNTHETIC_ID;
  sheet.getCell('D3').value = { formula: genderTemplate('E3'), result: '男' };
  sheet.getCell('F3').value = { formula: birthTemplate('E3'), result: new Date(Date.UTC(1990, 0, 2)) };
};

async function syntheticWorkbook(...mutations: WorkbookMutation[]): Promise<Buffer> {
  const workbook = new ExcelJS.Workbook();
  const sheet = workbook.addWorksheet('Sheet1');
  sheet.addRow(['脱敏团队名单模板']);
  sheet.addRow([...SOURCE_HEADERS]);
  sheet.addRow([
    1,
    '测试甲',
    'ALPHA，TEST',
    '男',
    '',
    '1990/1/2',
    { formula: 'DATEDIF(F3,TODAY(),"Y")', result: 36 },
    '测试地一',
    123456789,
    '测试签发地',
    new Date(Date.UTC(2025, 0, 2)),
    { formula: 'EDATE(K3,10*12)-1', result: new Date(Date.UTC(2035, 0, 1)) },
    13800000000,
    '领队\t备注'
  ]);
  sheet.addRow([
    2,
    '测试乙',
    'BETA,TEST',
    '女',
    '',
    36527,
    { formula: 'DATEDIF(F4,TODAY(),"Y")', result: 26 },
    '测试地二',
    'P00000002',
    '测试签发地',
    45659,
    49310,
    '',
    ''
  ]);
  for (const mutation of mutations) await mutation(workbook);
  return Buffer.from(await workbook.xlsx.writeBuffer());
}

async function erpHeaderWorkbook(...mutations: WorkbookMutation[]): Promise<Buffer> {
  const workbook = new ExcelJS.Workbook();
  const sheet = workbook.addWorksheet('ERP名单');
  sheet.addRow([...ERP_HEADERS]);
  sheet.addRow([
    1,
    '测试甲',
    'ALPHA，TEST',
    '男',
    '1990/1/2',
    '测试地一',
    '护照',
    123456789,
    '测试签发地',
    new Date(Date.UTC(2025, 0, 2)),
    new Date(Date.UTC(2035, 0, 1)),
    13800000000,
    '领队\t备注'
  ]);
  for (const mutation of mutations) await mutation(workbook);
  return Buffer.from(await workbook.xlsx.writeBuffer());
}

async function expectRosterError(
  work: () => Promise<unknown>,
  code: string,
  location?: { row?: number; column?: number }
): Promise<PassengerRosterWorkbookError> {
  try {
    await work();
  } catch (error) {
    assert.ok(error instanceof PassengerRosterWorkbookError, String(error));
    assert.equal(error.code, code);
    if (location?.row !== undefined) assert.equal(error.row, location.row);
    if (location?.column !== undefined) assert.equal(error.column, location.column);
    return error;
  }
  assert.fail(`expected ${code}`);
}

test('XLSX is deterministically normalized to the canonical 13-column TSV', async () => {
  const result = await normalizePassengerRosterWorkbook({
    content: await syntheticWorkbook(),
    fileName: 'synthetic-roster.xlsx',
    contentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
  });

  assert.equal(result.rowCount, 2);
  assert.equal(result.sourceFormat, 'xlsx');
  assert.equal(result.worksheetName, 'Sheet1');
  assert.equal(result.headerRow, 2);
  assert.equal(result.canonicalTsv, [
    CANONICAL_HEADER,
    '1\t测试甲\tALPHA,TEST\t男\t1990-01-02\t测试地一\t护照\t123456789\t测试签发地\t2025-01-02\t2035-01-01\t13800000000\t领队 备注',
    '2\t测试乙\tBETA,TEST\t女\t2000-01-02\t测试地二\t护照\tP00000002\t测试签发地\t2025-01-02\t2035-01-01\t\t'
  ].join('\n'));
});

test('an absent phone header produces blank phones without guessing unheaded values', async () => {
  const baseline = await normalizeSynthetic(await syntheticWorkbook());
  const expected = baseline.canonicalTsv.split('\n').map((line, index) => {
    if (index === 0) return line;
    const fields = line.split('\t');
    fields[11] = '';
    return fields.join('\t');
  }).join('\n');
  for (const removeColumn of [false, true]) {
    const result = await normalizeSynthetic(await syntheticWorkbook(workbook => {
      const sheet = workbook.getWorksheet('Sheet1')!;
      if (removeColumn) sheet.spliceColumns(13, 1);
      else sheet.getCell('M2').value = null; // The original number below remains unheaded.
    }));
    assert.equal(result.canonicalTsv, expected);
    assert.equal(result.rowCount, 2);
    const parsed = await parseProgramInput({
      rawText: `导入散拼子单名单\n预订客户:测试客户\n出发日期:2026-09-18\n名单内容:\n${result.canonicalTsv}`,
      receivedAt: new Date('2026-09-16T00:00:00Z')
    });
    assert.equal(parsed.status, 'agent_parse_passed');
  }
});

test('phone-free rosters support reordered alias headers, merged remarks and XLS conversion', async () => {
  const workbook = new ExcelJS.Workbook();
  const sheet = workbook.addWorksheet('无电话模板');
  sheet.mergeCells('B1:K1');
  sheet.getCell('B1').value = '脱敏团队信息';
  sheet.addRow(['序号', '姓名', '英文姓名', '护照号码', '性别', '出生日期', '年龄', '出生地点', '签发地', '签发日期', '有效期至', '备注']);
  for (let sequence = 1; sequence <= 8; sequence++) {
    sheet.addRow([sequence, '测试游客', 'TEST', `P0000000${sequence}`, '女', '1990-01-02', 36, '测试地', '测试地', '2025-01-02', '2035-01-01', '普通备注']);
  }
  sheet.mergeCells('L3:L10');
  sheet.getCell('M10').value = 13800000000; // Extra unheaded content must not become a phone.
  const xlsx = Buffer.from(await workbook.xlsx.writeBuffer());
  const expected = await normalizeSynthetic(xlsx);
  assert.equal(expected.rowCount, 8);
  for (const row of expected.canonicalTsv.split('\n').slice(1)) {
    assert.equal(row.split('\t').length, 13);
    assert.deepEqual(row.split('\t').slice(11), ['', '普通备注']);
  }
  assert.doesNotMatch(expected.canonicalTsv, /13800000000/);
  const legacy = await normalizePassengerRosterWorkbook({
    content: Buffer.from([0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1]),
    fileName: 'synthetic.xls', contentType: 'application/vnd.ms-excel'
  }, { convertLegacyXls: async () => xlsx });
  assert.equal(legacy.canonicalTsv, expected.canonicalTsv);
});

test('phone is the only optional semantic and duplicate phone headers stay blocked', async () => {
  for (const column of [1, 2, 3, 4, 6, 8, 9, 10, 11, 12, 14]) {
    const content = await syntheticWorkbook(workbook => {
      const sheet = workbook.getWorksheet('Sheet1')!;
      sheet.getCell('M2').value = null;
      sheet.getCell(2, column).value = null;
    });
    await expectRosterError(() => normalizeSynthetic(content), 'roster_workbook_header_not_found');
  }
  await expectRosterError(() => syntheticWorkbook(workbook => {
    workbook.getWorksheet('Sheet1')!.getCell('O2').value = '电话';
  }).then(normalizeSynthetic), 'roster_workbook_header_not_found');
});

test('present phone columns retain formula, value, hidden-data and row checks', async () => {
  for (const [value, code] of [
    [{ formula: '1+1', result: 2 }, 'roster_workbook_formula_not_allowed'],
    [{ error: '#VALUE!' }, 'roster_workbook_invalid_cell'],
    [1.5, 'roster_workbook_invalid_identifier']
  ] as const) {
    await expectRosterError(() => syntheticWorkbook(workbook => {
      workbook.getWorksheet('Sheet1')!.getCell('M3').value = value;
    }).then(normalizeSynthetic), code, { row: 3, column: 13 });
  }
  await expectRosterError(() => syntheticWorkbook(workbook => {
    workbook.getWorksheet('Sheet1')!.getColumn(13).hidden = true;
  }).then(normalizeSynthetic), 'roster_workbook_hidden_data');
  await expectRosterError(() => syntheticWorkbook(workbook => {
    workbook.getWorksheet('Sheet1')!.getCell('M5').value = '13800000000';
  }).then(normalizeSynthetic), 'roster_workbook_invalid_sequence', { row: 5, column: 1 });
});

test('a marked leader still requires a phone when the source phone column is absent', async () => {
  const result = await normalizeSynthetic(await syntheticWorkbook(workbook => {
    const sheet = workbook.getWorksheet('Sheet1')!;
    sheet.getCell('M2').value = null;
    sheet.getCell('N3').value = '领队';
  }));
  const parsed = await parseProgramInput({
    rawText: `导入散拼子单名单\n预订客户:测试客户\n出发日期:2026-09-18\n名单内容:\n${result.canonicalTsv}`,
    receivedAt: new Date('2026-09-16T00:00:00Z')
  });
  assert.notEqual(parsed.status, 'agent_parse_passed');
  assert.match(JSON.stringify(parsed), /姓名和电话都必须填写/);
});

test('a merged title error is skipped, while header and passenger errors stay blocked', async () => {
  const baseline = await normalizeSynthetic(await syntheticWorkbook());
  const titleError = await normalizeSynthetic(await syntheticWorkbook(workbook => {
    const sheet = workbook.getWorksheet('Sheet1')!;
    sheet.mergeCells('F1:N1');
    sheet.getCell('F1').value = { error: '#VALUE!' };
  }));
  assert.equal(titleError.canonicalTsv, baseline.canonicalTsv);
  for (const [address, code, row, column] of [
    ['F2', 'roster_workbook_header_not_found', undefined, undefined],
    ['F3', 'roster_workbook_invalid_cell', 3, 6],
    ['N4', 'roster_workbook_invalid_cell', 4, 14]
  ] as const) {
    const content = await syntheticWorkbook(workbook => {
      workbook.getWorksheet('Sheet1')!.getCell(address).value = { error: '#VALUE!' };
    });
    await expectRosterError(() => normalizeSynthetic(content), code, { row, column });
  }
});

test('same-row identity templates support 18 and 15 digit sources without exporting them', async () => {
  for (const legacy of [false, true]) {
    const normalized = await normalizeSynthetic(await syntheticWorkbook(identityFormulas, workbook => {
      const sheet = workbook.getWorksheet('Sheet1')!;
      sheet.getCell('E2').value = '身份证';
      if (legacy) {
        sheet.getCell('E3').value = 111111900102002;
        sheet.getCell('D3').value = { formula: genderTemplate('E3'), result: '女' };
      }
    }));
    const row = normalized.canonicalTsv.split('\n')[1]!.split('\t');
    assert.deepEqual(row.slice(3, 5), [legacy ? '女' : '男', '1990-01-02']);
    assert.equal(row[6], '护照');
    assert.equal(row[7], '123456789');
    assert.doesNotMatch(normalized.canonicalTsv, /111111|身份证/);
  }
});

test('identity references follow reordered columns, shared formulas and the workbook date system', async () => {
  const content = await syntheticWorkbook(identityFormulas, workbook => {
    const sheet = workbook.getWorksheet('Sheet1')!;
    for (const rowNumber of [2, 3, 4]) {
      const row = sheet.getRow(rowNumber);
      const values = REORDERED_SOURCE_INDEXES.map(index => row.getCell(index + 1).value);
      row.values = values;
    }
    workbook.properties.date1904 = true;
    const birthSerial = (Date.UTC(1990, 0, 2) - Date.UTC(1904, 0, 1)) / 86_400_000;
    sheet.getCell('I3').value = { formula: genderTemplate('$F3').toLowerCase(), result: '男' };
    sheet.getCell('K3').value = { formula: birthTemplate('F3'), result: birthSerial };
    sheet.getCell('J3').value = new Date(Date.UTC(2035, 0, 1));
    sheet.getCell('F4').value = SYNTHETIC_ID;
    sheet.getCell('I4').value = { sharedFormula: 'I3', result: '男' };
    sheet.getCell('K4').value = { sharedFormula: 'K3', result: birthSerial };
  });
  const result = await normalizeSynthetic(content);
  for (const row of result.canonicalTsv.split('\n').slice(1)) {
    assert.deepEqual(row.split('\t').slice(3, 5), ['男', '1990-01-02']);
  }
});

test('identity formulas reject missing, stale or error results at the formula cell', async () => {
  for (const [address, value, code, column] of [
    ['D3', { formula: genderTemplate('E3') }, 'roster_workbook_formula_result_missing', 4],
    ['F3', { formula: birthTemplate('E3') }, 'roster_workbook_formula_result_missing', 6],
    ['D3', { formula: genderTemplate('E3'), result: '女' }, 'roster_workbook_formula_result_mismatch', 4],
    ['F3', { formula: birthTemplate('E3'), result: '1990-01-03' }, 'roster_workbook_formula_result_mismatch', 6],
    ['F3', { formula: birthTemplate('E3'), result: { error: '#VALUE!' } }, 'roster_workbook_invalid_cell', 6]
  ] as const) {
    const content = await syntheticWorkbook(identityFormulas, workbook => {
      workbook.getWorksheet('Sheet1')!.getCell(address).value = value;
    });
    await expectRosterError(() => normalizeSynthetic(content), code, { row: 3, column });
  }
});

test('identity dependencies must be unambiguous same-row template references', async () => {
  const variants: Array<[WorkbookMutation, string, number]> = [
    [workbook => { workbook.getWorksheet('Sheet1')!.getCell('E2').value = '普通额外列'; }, 'roster_workbook_formula_not_allowed', 4],
    [workbook => { workbook.getWorksheet('Sheet1')!.getCell('O2').value = '身份证'; }, 'roster_workbook_formula_not_allowed', 4],
    [workbook => { workbook.getWorksheet('Sheet1')!.getCell('D3').value = { formula: genderTemplate('E4'), result: '男' }; }, 'roster_workbook_formula_not_allowed', 4],
    [workbook => { workbook.getWorksheet('Sheet1')!.getCell('D3').value = { formula: '"男"', result: '男' }; }, 'roster_workbook_formula_not_allowed', 4],
    [workbook => { workbook.getWorksheet('Sheet1')!.getCell('F3').value = { formula: birthTemplate('E3').replaceAll(';', ','), result: '1990-01-02' }; }, 'roster_workbook_formula_not_allowed', 6],
    [workbook => { workbook.getWorksheet('Sheet1')!.getCell('D3').value = { formula: genderTemplate("'[external.xlsx]Sheet1'!E3"), result: '男' }; }, 'roster_workbook_unsafe_content', 4]
  ];
  for (const [mutation, code, column] of variants) {
    const content = await syntheticWorkbook(identityFormulas, mutation);
    await expectRosterError(() => normalizeSynthetic(content), code, { row: 3, column });
  }
});

test('invalid identity sources cannot validate a cached gender or birth date', async () => {
  for (const [value, code] of [
    ['', 'roster_workbook_invalid_identifier'],
    ['invalid source', 'roster_workbook_invalid_identifier'],
    [` ${SYNTHETIC_ID}`, 'roster_workbook_invalid_identifier'],
    [`${SYNTHETIC_ID}\n`, 'roster_workbook_invalid_identifier'],
    [`111111\t${SYNTHETIC_ID.slice(6)}`, 'roster_workbook_invalid_identifier'],
    [111111199001020010, 'roster_workbook_invalid_identifier'],
    ['11111119900230001X', 'roster_workbook_invalid_date'],
    [{ formula: '"11111119900102001X"', result: SYNTHETIC_ID }, 'roster_workbook_formula_not_allowed']
  ] as const) {
    const content = await syntheticWorkbook(identityFormulas, workbook => {
      workbook.getWorksheet('Sheet1')!.getCell('E3').value = value;
    });
    const error = await expectRosterError(() => normalizeSynthetic(content), code, { row: 3, column: 5 });
    assert.doesNotMatch(JSON.stringify(error), /111111|invalid source/);
  }
});

test('populated identity formula rows are not discarded as empty trailing templates', async () => {
  const content = await syntheticWorkbook(identityFormulas, workbook => {
    const sheet = workbook.getWorksheet('Sheet1')!;
    sheet.getRow(5).values = [3, '', '', { formula: genderTemplate('E5'), result: '男' }, SYNTHETIC_ID,
      { formula: birthTemplate('E5'), result: '1990-01-02' }];
  });
  const result = await normalizeSynthetic(content);
  assert.equal(result.rowCount, 3);
  // Retain the partial row for downstream import/supplement validation.
  assert.deepEqual(result.canonicalTsv.split('\n')[3]!.split('\t').slice(0, 5), ['3', '', '', '男', '1990-01-02']);
});

test('a 22-person template passes normalization and program parsing with the last row as leader', async () => {
  const content = await syntheticWorkbook(identityFormulas, workbook => {
    const sheet = workbook.getWorksheet('Sheet1')!;
    sheet.mergeCells('F1:N1');
    sheet.getCell('F1').value = { error: '#VALUE!' };
    const values = sheet.getRow(3).values;
    for (let index = 1; index <= 22; index++) {
      const rowNumber = index + 2;
      const row = sheet.getRow(rowNumber);
      row.values = values;
      row.getCell('A').value = index;
      row.getCell('I').value = `P${String(index).padStart(8, '0')}`;
      row.getCell('D').value = { formula: genderTemplate(`E${rowNumber}`), result: '男' };
      row.getCell('F').value = { formula: birthTemplate(`E${rowNumber}`), result: '1990-01-02' };
      row.getCell('K').value = { formula: `EDATE(L${rowNumber},-10*12)+1`, result: '2025-01-02' };
      row.getCell('L').value = '2035-01-01';
      row.getCell('M').value = index === 22 ? '13800000000' : '';
      row.getCell('N').value = index === 22 ? '领队' : '';
    }
  });
  const result = await normalizeSynthetic(content);
  assert.equal(result.rowCount, 22);
  assert.doesNotMatch(result.canonicalTsv, /111111|身份证|#VALUE!/);
  const parsed = await parseProgramInput({ rawText: `导入散拼子单名单\n预订客户:测试客户\n出发日期:2026-09-21\n名单内容:\n${result.canonicalTsv}`,
    receivedAt: new Date('2026-09-15T00:00:00Z') });
  assert.equal(parsed.status, 'agent_parse_passed');
  const data = parsed.operation?.data as { passenger_list?: { leader_contact?: { sequence?: number } } };
  assert.equal(data?.passenger_list?.leader_contact?.sequence, 22);
});

test('the ERP field row is auto-detected and source columns may be reordered', async () => {
  const valid = await syntheticWorkbook((workbook) => {
    workbook.getWorksheet('Sheet1')!.getCell('N1').value = '任意团信息';
  });
  const normalized = await normalizePassengerRosterWorkbook({
    content: valid,
    fileName: 'synthetic.xlsx',
    contentType: 'application/octet-stream'
  });
  assert.equal(normalized.headerRow, 2);
  assert.equal(normalized.rowCount, 2);

  const reordered = await syntheticWorkbook((workbook) => {
    const sheet = workbook.getWorksheet('Sheet1')!;
    for (const rowNumber of [2, 3, 4]) {
      const row = sheet.getRow(rowNumber);
      const values = REORDERED_SOURCE_INDEXES.map((index) => row.getCell(index + 1).value);
      row.values = values;
    }
    sheet.getCell('G3').value = {
      formula: 'DATEDIF(K3,TODAY(),"Y")',
      result: 36
    };
    sheet.getCell('J3').value = {
      formula: 'EDATE(E3,10*12)-1',
      result: new Date(Date.UTC(2035, 0, 1))
    };
    sheet.getCell('G4').value = {
      formula: 'DATEDIF(K4,TODAY(),"Y")',
      result: 26
    };
    sheet.getCell('J4').value = {
      formula: 'EDATE(E4,10*12)-1',
      result: 49310
    };
  });
  const reorderedResult = await normalizePassengerRosterWorkbook({
    content: reordered,
    fileName: 'reordered-roster.xlsx',
    contentType: 'application/octet-stream'
  });
  assert.equal(reorderedResult.headerRow, 2);
  assert.equal(reorderedResult.canonicalTsv, [
    CANONICAL_HEADER,
    '1\t测试甲\tALPHA,TEST\t男\t1990-01-02\t测试地一\t护照\t123456789\t测试签发地\t2025-01-02\t2035-01-01\t13800000000\t领队 备注',
    '2\t测试乙\tBETA,TEST\t女\t2000-01-02\t测试地二\t护照\tP00000002\t测试签发地\t2025-01-02\t2035-01-01\t\t'
  ].join('\n'));

  const shifted = await syntheticWorkbook((workbook) => {
    const sheet = workbook.getWorksheet('Sheet1')!;
    sheet.insertRow(2, ['额外说明']);
    sheet.getCell('G4').value = {
      formula: 'DATEDIF(F4,TODAY(),"Y")',
      result: 36
    };
    sheet.getCell('L4').value = {
      formula: 'EDATE(K4,10*12)-1',
      result: new Date(Date.UTC(2035, 0, 1))
    };
    sheet.getCell('G5').value = {
      formula: 'DATEDIF(F5,TODAY(),"Y")',
      result: 26
    };
    sheet.getCell('L5').value = {
      formula: 'EDATE(K5,10*12)-1',
      result: 49310
    };
  });
  const shiftedResult = await normalizePassengerRosterWorkbook({
    content: shifted,
    fileName: 'synthetic.xlsx',
    contentType: 'application/octet-stream'
  });
  assert.equal(shiftedResult.headerRow, 3);
  assert.equal(shiftedResult.rowCount, 2);

  const erpHeaderOnFirstRow = await normalizePassengerRosterWorkbook({
    content: await erpHeaderWorkbook(),
    fileName: 'erp-roster.xlsx',
    contentType: 'application/octet-stream'
  });
  assert.equal(erpHeaderOnFirstRow.headerRow, 1);
  assert.equal(erpHeaderOnFirstRow.canonicalTsv, [
    CANONICAL_HEADER,
    '1\t测试甲\tALPHA,TEST\t男\t1990-01-02\t测试地一\t护照\t123456789\t测试签发地\t2025-01-02\t2035-01-01\t13800000000\t领队 备注'
  ].join('\n'));
});

test('the approved attachment aliases and reverse issue-date formula are normalized', async () => {
  const attachmentVariant = await syntheticWorkbook((workbook) => {
    const sheet = workbook.getWorksheet('Sheet1')!;
    for (const rowNumber of [2, 3, 4]) {
      const row = sheet.getRow(rowNumber);
      const values = ATTACHMENT_VARIANT_INDEXES.map((index) => row.getCell(index + 1).value);
      row.values = values;
    }
    sheet.getCell('N2').value = '身份证';
    sheet.getCell('F3').value = 36;
    sheet.getCell('J3').value = {
      formula: 'EDATE(K3,-10*12)+1',
      result: new Date(Date.UTC(2025, 0, 2))
    };
    sheet.getCell('K3').value = new Date(Date.UTC(2035, 0, 1));
    sheet.getCell('F4').value = 26;
    sheet.getCell('J4').value = {
      formula: 'EDATE(K4,-10*12)+1',
      result: 45659
    };
    sheet.getCell('K4').value = 49310;
  });

  const result = await normalizePassengerRosterWorkbook({
    content: attachmentVariant,
    fileName: 'attachment-variant.xlsx',
    contentType: 'application/octet-stream'
  });
  assert.equal(result.headerRow, 2);
  assert.equal(result.canonicalTsv, [
    CANONICAL_HEADER,
    '1\t测试甲\tALPHA,TEST\t男\t1990-01-02\t测试地一\t护照\t123456789\t测试签发地\t2025-01-02\t2035-01-01\t13800000000\t领队 备注',
    '2\t测试乙\tBETA,TEST\t女\t2000-01-02\t测试地二\t护照\tP00000002\t测试签发地\t2025-01-02\t2035-01-01\t\t'
  ].join('\n'));
});

test('birthplace and expiry aliases preserve the canonical passenger fields and values', async () => {
  const normalize = (content: Buffer) => normalizePassengerRosterWorkbook({
    content, fileName: 'synthetic.xlsx', contentType: 'application/octet-stream'
  });
  const original = await normalize(await syntheticWorkbook());
  const aliased = await normalize(await syntheticWorkbook(workbook => {
    const sheet = workbook.getWorksheet('Sheet1')!;
    sheet.getCell('H2').value = '出生地点';
    sheet.getCell('L2').value = '有效期至';
  }));
  assert.equal(aliased.headerRow, original.headerRow);
  assert.equal(aliased.rowCount, original.rowCount);
  assert.equal(aliased.canonicalTsv, original.canonicalTsv);
});

test('birthplace and expiry aliases cannot silently select duplicate semantic columns', async () => {
  for (const [column, alias] of [['H2', '出生地点'], ['L2', '有效期至']] as const) {
    for (const duplicate of ['canonical', 'alias'] as const) {
      const content = await syntheticWorkbook(workbook => {
        const sheet = workbook.getWorksheet('Sheet1')!;
        const original = sheet.getCell(column).value;
        sheet.getCell(column).value = alias;
        sheet.getCell('O2').value = duplicate === 'canonical' ? original : alias;
        sheet.getCell('O3').value = '合成冲突值';
      });
      await expectRosterError(
        () => normalizePassengerRosterWorkbook({ content, fileName: 'synthetic.xlsx', contentType: 'application/octet-stream' }),
        'roster_workbook_header_not_found'
      );
    }
  }
});

test('source header order may vary, but every required label must appear exactly once', async () => {
  const missingHeader = await syntheticWorkbook((workbook) => {
    workbook.getWorksheet('Sheet1')!.getCell('N2').value = '备注说明';
  });
  await expectRosterError(
    () => normalizePassengerRosterWorkbook({ content: missingHeader, fileName: 'synthetic.xlsx', contentType: 'application/octet-stream' }),
    'roster_workbook_header_not_found'
  );

  const duplicateHeader = await syntheticWorkbook((workbook) => {
    workbook.getWorksheet('Sheet1')!.getCell('N2').value = '姓名';
  });
  await expectRosterError(
    () => normalizePassengerRosterWorkbook({ content: duplicateHeader, fileName: 'synthetic.xlsx', contentType: 'application/octet-stream' }),
    'roster_workbook_header_not_found'
  );

  const ignoredExtraData = await syntheticWorkbook((workbook) => {
    const sheet = workbook.getWorksheet('Sheet1')!;
    sheet.getCell('O2').value = '酒店偏好';
    sheet.getCell('O3').value = 'SYNTHETIC-EXTRA-SHOULD-NOT-LEAK';
    sheet.getCell('P3').value = { formula: '1+1' };
    sheet.getCell('Q6').value = '仅额外列尾注';
  });
  const ignoredExtraResult = await normalizePassengerRosterWorkbook({
    content: ignoredExtraData,
    fileName: 'synthetic.xlsx',
    contentType: 'application/octet-stream'
  });
  assert.equal(ignoredExtraResult.rowCount, 2);
  assert.doesNotMatch(ignoredExtraResult.canonicalTsv, /SYNTHETIC-EXTRA-SHOULD-NOT-LEAK|酒店偏好|仅额外列尾注/);
});

test('legacy XLS is accepted only through an injected fail-closed converter', async () => {
  const xlsx = await syntheticWorkbook();
  const legacy = Buffer.concat([
    Buffer.from([0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1]),
    Buffer.from('synthetic legacy workbook')
  ]);
  let conversions = 0;
  const result = await normalizePassengerRosterWorkbook({
    content: legacy,
    fileName: 'synthetic-roster.xls',
    contentType: 'application/vnd.ms-excel'
  }, {
    convertLegacyXls: async (input) => {
      conversions += 1;
      assert.equal(input.content, legacy);
      return xlsx;
    }
  });
  assert.equal(conversions, 1);
  assert.equal(result.sourceFormat, 'xls');
  assert.equal(result.rowCount, 2);

  await expectRosterError(
    () => normalizePassengerRosterWorkbook({
      content: legacy,
      fileName: 'synthetic-roster.xls',
      contentType: 'application/vnd.ms-excel'
    }),
    'roster_workbook_converter_unavailable'
  );
});

test('identity cards and other non-import columns are ignored without leaking values', async () => {
  const secret = 'SYNTHETIC-ID-SHOULD-NOT-LEAK';
  const content = await syntheticWorkbook((workbook) => {
    const sheet = workbook.getWorksheet('Sheet1')!;
    sheet.getCell('E3').value = secret;
    sheet.getColumn(5).hidden = true;
  });
  const result = await normalizePassengerRosterWorkbook({
    content,
    fileName: 'synthetic.xlsx',
    contentType: 'application/octet-stream'
  });
  assert.equal(result.rowCount, 2);
  assert.doesNotMatch(result.canonicalTsv, new RegExp(secret));
});

test('source document type is ignored and canonical ERP document type remains passport', async () => {
  const sourceType = await erpHeaderWorkbook((workbook) => {
    workbook.getWorksheet('ERP名单')!.getCell('G2').value = '身份证';
  });
  const result = await normalizePassengerRosterWorkbook({
    content: sourceType,
    fileName: 'erp-roster.xlsx',
    contentType: 'application/octet-stream'
  });
  assert.equal(result.rowCount, 1);
  assert.equal(result.canonicalTsv.split('\n')[1]!.split('\t')[6], '护照');
  assert.doesNotMatch(result.canonicalTsv, /身份证/);
});

test('sequence numbers must be positive and unique', async () => {
  const duplicate = await syntheticWorkbook((workbook) => {
    workbook.getWorksheet('Sheet1')!.getCell('A4').value = 1;
  });
  await expectRosterError(
    () => normalizePassengerRosterWorkbook({ content: duplicate, fileName: 'synthetic.xlsx', contentType: 'application/octet-stream' }),
    'roster_workbook_duplicate_sequence',
    { row: 4, column: 1 }
  );

  const decimal = await syntheticWorkbook((workbook) => {
    workbook.getWorksheet('Sheet1')!.getCell('A3').value = 1.5;
  });
  await expectRosterError(
    () => normalizePassengerRosterWorkbook({ content: decimal, fileName: 'synthetic.xlsx', contentType: 'application/octet-stream' }),
    'roster_workbook_invalid_sequence',
    { row: 3, column: 1 }
  );

  const overTechnicalLimit = await syntheticWorkbook((workbook) => {
    workbook.getWorksheet('Sheet1')!.getCell('A3').value = 5001;
  });
  await expectRosterError(
    () => normalizePassengerRosterWorkbook({ content: overTechnicalLimit, fileName: 'synthetic.xlsx', contentType: 'application/octet-stream' }),
    'roster_workbook_sequence_limit',
    { row: 3, column: 1 }
  );
});

test('unsafe formulas stay blocked while ignored columns do not affect selected fields', async () => {
  const networkFormula = await syntheticWorkbook((workbook) => {
    workbook.getWorksheet('Sheet1')!.getCell('G3').value = {
      formula: 'WEBSERVICE("https://invalid.example")',
      result: '36'
    };
  });
  await expectRosterError(
    () => normalizePassengerRosterWorkbook({ content: networkFormula, fileName: 'synthetic.xlsx', contentType: 'application/octet-stream' }),
    'roster_workbook_unsafe_content',
    { row: 3, column: 7 }
  );

  const crossRowFormula = await syntheticWorkbook((workbook) => {
    workbook.getWorksheet('Sheet1')!.getCell('L3').value = {
      formula: 'EDATE(K4,10*12)-1',
      result: new Date(Date.UTC(2035, 0, 1))
    };
  });
  await expectRosterError(
    () => normalizePassengerRosterWorkbook({ content: crossRowFormula, fileName: 'synthetic.xlsx', contentType: 'application/octet-stream' }),
    'roster_workbook_formula_not_allowed',
    { row: 3, column: 12 }
  );

  const ignoredAgeWithoutResult = await syntheticWorkbook((workbook) => {
    workbook.getWorksheet('Sheet1')!.getCell('G3').value = {
      formula: 'DATEDIF(F3,TODAY(),"Y")'
    };
  });
  const ignoredAgeResult = await normalizePassengerRosterWorkbook({
    content: ignoredAgeWithoutResult,
    fileName: 'synthetic.xlsx',
    contentType: 'application/octet-stream'
  });
  assert.equal(ignoredAgeResult.rowCount, 2);

  const expiryWithoutResult = await syntheticWorkbook((workbook) => {
    workbook.getWorksheet('Sheet1')!.getCell('L3').value = {
      formula: 'EDATE(K3,10*12)-1'
    };
  });
  await expectRosterError(
    () => normalizePassengerRosterWorkbook({ content: expiryWithoutResult, fileName: 'synthetic.xlsx', contentType: 'application/octet-stream' }),
    'roster_workbook_formula_result_missing',
    { row: 3, column: 12 }
  );

  const issueDateWithoutResult = await syntheticWorkbook((workbook) => {
    const sheet = workbook.getWorksheet('Sheet1')!;
    sheet.getCell('K3').value = {
      formula: 'EDATE(L3,-10*12)+1'
    };
    sheet.getCell('L3').value = new Date(Date.UTC(2035, 0, 1));
  });
  await expectRosterError(
    () => normalizePassengerRosterWorkbook({ content: issueDateWithoutResult, fileName: 'synthetic.xlsx', contentType: 'application/octet-stream' }),
    'roster_workbook_formula_result_missing',
    { row: 3, column: 11 }
  );
});

test('macros, external relationships and ambiguous sheets fail closed', async () => {
  const xlsx = await syntheticWorkbook();
  const zip = await JSZip.loadAsync(xlsx);
  zip.file('xl/vbaProject.bin', Buffer.from('synthetic macro'));
  const macroWorkbook = await zip.generateAsync({ type: 'nodebuffer' });
  await expectRosterError(
    () => normalizePassengerRosterWorkbook({ content: macroWorkbook, fileName: 'synthetic.xlsx', contentType: 'application/octet-stream' }),
    'roster_workbook_unsafe_content'
  );

  const relationshipZip = await JSZip.loadAsync(xlsx);
  const relationshipPath = 'xl/_rels/workbook.xml.rels';
  const relationships = await relationshipZip.file(relationshipPath)!.async('string');
  relationshipZip.file(
    relationshipPath,
    relationships.replace(
      '</Relationships>',
      '<Relationship Id="syntheticExternal" Type="urn:synthetic" Target="https://invalid.example" TargetMode="External"/></Relationships>'
    )
  );
  const externalRelationship = await relationshipZip.generateAsync({ type: 'nodebuffer' });
  await expectRosterError(
    () => normalizePassengerRosterWorkbook({ content: externalRelationship, fileName: 'synthetic.xlsx', contentType: 'application/octet-stream' }),
    'roster_workbook_unsafe_content'
  );

  const externalFormula = await syntheticWorkbook((workbook) => {
    workbook.getWorksheet('Sheet1')!.getCell('L3').value = {
      formula: "'[external.xlsx]Sheet1'!A1",
      result: new Date(Date.UTC(2035, 0, 1))
    };
  });
  await expectRosterError(
    () => normalizePassengerRosterWorkbook({ content: externalFormula, fileName: 'synthetic.xlsx', contentType: 'application/octet-stream' }),
    'roster_workbook_unsafe_content'
  );

  const multipleSheets = await syntheticWorkbook((workbook) => {
    workbook.addWorksheet('Extra');
  });
  await expectRosterError(
    () => normalizePassengerRosterWorkbook({ content: multipleSheets, fileName: 'synthetic.xlsx', contentType: 'application/octet-stream' }),
    'roster_workbook_ambiguous_sheet'
  );
});

test('hidden non-empty rows or columns and duplicate headers fail closed', async () => {
  const hiddenRow = await syntheticWorkbook((workbook) => {
    workbook.getWorksheet('Sheet1')!.getRow(4).hidden = true;
  });
  await expectRosterError(
    () => normalizePassengerRosterWorkbook({ content: hiddenRow, fileName: 'synthetic.xlsx', contentType: 'application/octet-stream' }),
    'roster_workbook_hidden_data',
    { row: 4 }
  );

  const hiddenColumn = await syntheticWorkbook((workbook) => {
    workbook.getWorksheet('Sheet1')!.getColumn(14).hidden = true;
  });
  await expectRosterError(
    () => normalizePassengerRosterWorkbook({ content: hiddenColumn, fileName: 'synthetic.xlsx', contentType: 'application/octet-stream' }),
    'roster_workbook_hidden_data',
    { column: 14 }
  );

  const duplicateHeaders = await syntheticWorkbook((workbook) => {
    workbook.getWorksheet('Sheet1')!.addRow([...SOURCE_HEADERS]);
  });
  await expectRosterError(
    () => normalizePassengerRosterWorkbook({ content: duplicateHeaders, fileName: 'synthetic.xlsx', contentType: 'application/octet-stream' }),
    'roster_workbook_ambiguous_header'
  );
});

test('format, MIME, conversion output and technical limits are validated before parsing', async () => {
  const xlsx = await syntheticWorkbook();
  await expectRosterError(
    () => normalizePassengerRosterWorkbook({ content: xlsx, fileName: 'synthetic.xls', contentType: 'application/vnd.ms-excel' }),
    'roster_workbook_format_mismatch'
  );
  await expectRosterError(
    () => normalizePassengerRosterWorkbook({ content: xlsx, fileName: 'synthetic.xlsx', contentType: 'application/octet-stream' }, { maxInputBytes: 8 }),
    'roster_workbook_too_large'
  );

  const legacy = Buffer.concat([
    Buffer.from([0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1]),
    Buffer.from('synthetic legacy workbook')
  ]);
  await expectRosterError(
    () => normalizePassengerRosterWorkbook({
      content: legacy,
      fileName: 'synthetic.xls',
      contentType: 'application/vnd.ms-excel'
    }, { convertLegacyXls: async () => Buffer.from('not xlsx') }),
    'roster_workbook_conversion_failed'
  );
  const conversionFailure = await expectRosterError(
    () => normalizePassengerRosterWorkbook({
      content: legacy,
      fileName: 'synthetic.xls',
      contentType: 'application/vnd.ms-excel'
    }, {
      convertLegacyXls: async () => {
        throw new PassengerRosterWorkbookError('roster_workbook_conversion_failed', {
          conversionErrorCode: 'conversion_output_missing'
        });
      }
    }),
    'roster_workbook_conversion_failed'
  );
  assert.equal(conversionFailure.conversionErrorCode, 'conversion_output_missing');

  const macroLegacy = Buffer.concat([legacy, Buffer.from('_VBA_PROJECT_CUR', 'utf16le')]);
  await expectRosterError(
    () => normalizePassengerRosterWorkbook({
      content: macroLegacy,
      fileName: 'synthetic.xls',
      contentType: 'application/vnd.ms-excel'
    }, { convertLegacyXls: async () => xlsx }),
    'roster_workbook_unsafe_content'
  );

  const tooManyRows = await syntheticWorkbook((workbook) => {
    const sheet = workbook.getWorksheet('Sheet1')!;
    for (let sequence = 3; sequence <= 5001; sequence += 1) {
      sheet.addRow([
        sequence, `测试${sequence}`, `TEST,${sequence}`, '男', '', '2000-01-01', '', '测试地',
        `P${String(sequence).padStart(8, '0')}`, '测试签发地', '2025-01-01', '2035-01-01', '', ''
      ]);
    }
  });
  await expectRosterError(
    () => normalizePassengerRosterWorkbook({
      content: tooManyRows,
      fileName: 'synthetic.xlsx',
      contentType: 'application/octet-stream'
    }, { maxDataRows: 6000 }),
    'roster_workbook_row_limit'
  );
});