/* Pure storage/matching checks, including the user-supplied ZIP. */
'use strict';
const assert = require('node:assert/strict');
const fs = require('node:fs');
const path = require('node:path');
const vm = require('node:vm');
const rootDir = path.resolve(__dirname, '..');
const bankSource = fs.readFileSync(path.join(rootDir, 'bank-store.js'), 'utf8');
const matcherSource = fs.readFileSync(path.join(rootDir, 'answer-matcher.js'), 'utf8');
const JSZip = require(path.join(rootDir, 'vendor', 'jszip.min.js'));

function runtime(kind = 'legacy', memory = new Map()) {
  const environment = { TextDecoder, URL, URLSearchParams, JSZip, console };
  if (kind === 'legacy') {
    environment.GM_getValue = (key, fallback) => memory.has(key) ? structuredClone(memory.get(key)) : fallback;
    environment.GM_setValue = (key, value) => { memory.set(key, structuredClone(value)); };
  } else if (kind === 'modern') {
    environment.GM = {
      getValue: async (key, fallback) => memory.has(key) ? structuredClone(memory.get(key)) : fallback,
      setValue: async (key, value) => { memory.set(key, structuredClone(value)); }
    };
  } else {
    environment.localStorage = { getItem: key => memory.get(key) ?? null, setItem: (key, value) => memory.set(key, value) };
  }
  vm.createContext(environment);
  vm.runInContext(bankSource, environment);
  vm.runInContext(matcherSource, environment);
  return { store: environment.YianBankStore, matcher: environment.YianAnswerMatcher, environment, memory };
}

function file(name, text) {
  const bytes = Buffer.isBuffer(text) ? text : Buffer.from(text);
  return { name, size: bytes.length, arrayBuffer: async () => bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) };
}

function record(overrides = {}) {
  return {
    role: '主操', course: '风险管理', sourceUrl: 'http://old-host/clientcn/exam/risk/questions?title=x&flag=exercise', number: 1,
    type: '单选', question: '温度低于 -50.5 ℃ 时，不应进行的作业？',
    options: [{ label: 'A', text: '作业甲' }, { label: 'B', text: '作业乙' }, { label: 'C', text: '作业丙' }],
    answer: 'B', explanation: '', ...overrides
  };
}

function csv(rows) {
  const headers = ['题号', '题型', '题目', '选项A', '选项B', '选项C', '参考答案', '题目解析', '来源网址', '题库名称'];
  const cell = value => '"' + String(value ?? '').replace(/"/g, '""') + '"';
  return '\uFEFF' + [headers, ...rows.map(row => [row.number, row.type, row.question, ...['A', 'B', 'C'].map(label => row.options.find(option => option.label === label)?.text || ''), row.answer, row.explanation, row.sourceUrl, row.course])].map(row => row.map(cell).join(',')).join('\r\n') + '\r\n';
}

(async () => {
  const { store, matcher, memory } = runtime();
  assert.equal((await store.load()).storage, 'userscript');
  assert.equal((await store.load()).total, 0);
  assert.deepEqual(Array.from(store.roles), ['主操', '班长', '副操']);
  const parsed = store.parseCSV('\uFEFF"题目","选项A"\r\n"逗号,引号""和\n换行","甲"\r\n');
  assert.equal(parsed[1][0], '逗号,引号"和\n换行');
  assert.throws(() => store.parseCSV('a,b\n"未闭合'), /未闭合/);
  assert.throws(() => store.parseCSV('a,b\n"关闭"坏,b'), /非法字符/);
  assert.throws(() => store.parseCSV('a,b\n未"转义,b'), /未转义/);
  assert.notEqual(matcher.normalize('不应在 -50.5℃ 作业'), matcher.normalize('应在 50.5℃ 作业'));
  assert.notEqual(matcher.normalize('50.5'), matcher.normalize('505'));
  assert.equal(matcher.normalize('−50.5 ℃'), '−50.5 ℃');
  assert.equal(matcher.normalize('  M\u200bPa\t\n  10\u00a0℃\uFEFF '), 'MPa 10 ℃');
  for (const [left, right] of [['MPa', 'mPa'], ['m²', 'm2'], ['Ⅰ', 'I'], ['不是', '是'], ['−50', '-50'], ['1.0', '10'], ['A，B', 'A,B']]) {
    assert.notEqual(matcher.normalize(left), matcher.normalize(right), '自动匹配必须区分 ' + left + ' / ' + right);
    assert.equal(store.normalize(left), matcher.normalize(left), '存储与匹配的严格规范化必须一致');
  }
  assert.equal(matcher.searchNormalize('−50.5 ℃'), '-50.5 °c');
  assert.equal(matcher.searchNormalize('ＭＰＡ'), matcher.searchNormalize('MPa'));

  // Loose search may find similar units, but cannot merge or authorize a different unit.
  const semanticRecords = [
    store.validateRecord(record({ question: '压力单位 MPa 应怎样使用？', options: [{ label: 'A', text: 'MPa' }, { label: 'B', text: 'mPa' }], answer: 'A' })),
    store.validateRecord(record({ question: '压力单位 mPa 应怎样使用？', options: [{ label: 'A', text: 'MPa' }, { label: 'B', text: 'mPa' }], answer: 'B' }))
  ];
  const semanticState = { records: semanticRecords, revision: 1 };
  assert.equal(matcher.search('mpa', { role: '主操' }, semanticState).total, 2);
  const pressurePage = { ...semanticRecords[0], options: [{ label: 'A', text: 'mPa' }, { label: 'B', text: 'MPa' }] };
  const pressureAnswer = matcher.match(pressurePage, { role: '主操' }, semanticState);
  assert.equal(pressureAnswer.status, 'matched');
  assert.deepEqual(Array.from(pressureAnswer.correctLabels), ['B']);
  assert.deepEqual(Array.from(pressureAnswer.correctTexts), ['MPa']);
  assert.throws(() => store.validateRecord({ ...semanticRecords[0], correctTexts: ['mPa'] }), /不一致/, '答案校验不能混淆单位大小写');
  for (const [bankText, pageText] of [['MPa', 'mPa'], ['m²', 'm2'], ['Ⅰ', 'I'], ['不应', '应'], ['50.5', '505']]) {
    const evidence = store.validateRecord(record({ question: '语义不能被自动改写。', options: [{ label: 'A', text: bankText }, { label: 'B', text: '其他选项' }], answer: 'A' }));
    const modifiedPage = { ...evidence, options: [{ label: 'A', text: pageText }, { label: 'B', text: '其他选项' }] };
    assert.equal(matcher.match(modifiedPage, { role: '主操' }, { records: [evidence], revision: 1 }).status, 'missing', bankText + ' 不得误匹配 ' + pageText);
    assert.notEqual(store.optionKey(evidence.options), store.optionKey(modifiedPage.options));
  }
  const evidenceRecord = store.validateRecord(record({ options: [{ label: 'A', text: 'MPa  10\n设备' }, { label: 'B', text: '备用设备' }], answer: 'A' }));
  const evidenceAnswer = matcher.match({ ...evidenceRecord, options: [{ label: 'A', text: '备用设备' }, { label: 'B', text: 'MPa 10 设备' }] }, { role: '主操' }, { records: [evidenceRecord], revision: 1 });
  assert.equal(evidenceAnswer.status, 'matched');
  assert.deepEqual(Array.from(evidenceAnswer.correctLabels), ['B']);
  assert.deepEqual(Array.from(evidenceAnswer.correctTexts), ['MPa  10\n设备'], '返回正确文字须保留题库证据原文');
  evidenceAnswer.correctTexts[0] = '不能改写题库';
  assert.equal(evidenceRecord.correctTexts[0], 'MPa  10\n设备', '结果数组不应直接暴露题库答案数组');
  const multiEvidence = store.validateRecord(record({ type: '多选', options: [{ label: 'A', text: 'MPa  10\n设备' }, { label: 'B', text: '备用\n设备' }, { label: 'C', text: '无关设备' }], answer: 'AB' }));
  const multiEvidenceAnswer = matcher.match({ ...multiEvidence, options: [{ label: 'A', text: '备用 设备' }, { label: 'B', text: '无关设备' }, { label: 'C', text: 'MPa 10 设备' }] }, { role: '主操' }, { records: [multiEvidence], revision: 1 });
  assert.equal(multiEvidenceAnswer.status, 'matched');
  assert.deepEqual(Array.from(multiEvidenceAnswer.correctLabels), ['A', 'C']);
  assert.deepEqual(Array.from(multiEvidenceAnswer.correctTexts), ['备用\n设备', 'MPa  10\n设备'], '多选映射后逐项对应字母，保留每个选项的题库原文空白');
  const sameStemDifferentAnswers = [semanticRecords[0], store.validateRecord({ ...semanticRecords[0], course: '另一课程', answer: 'B', correctTexts: undefined })];
  assert.equal(matcher.match(pressurePage, { role: '主操' }, { records: sameStemDifferentAnswers, revision: 1 }).status, 'conflict', '不同大小写的正确文本应保留为答案冲突');

  // Existing v2 data retains its source texts; recompute stale loose keys in memory.
  const oldMemory = new Map([['yianxue.assistant.bank.v2', {
    records: semanticRecords.map(item => ({ ...item, questionKey: 'old-loose-key', optionKey: 'old-loose-options', id: 'old-id' })),
    revision: 7, updatedAt: '2026-10-10T00:00:00.000Z'
  }]]);
  const upgraded = await runtime('modern', oldMemory).store.load();
  assert.equal(upgraded.total, 2, '回读旧库不丢失语义不同的记录');
  assert.equal(upgraded.revision, 7);
  assert.equal(upgraded.updatedAt, '2026-10-10T00:00:00.000Z');
  upgraded.records.forEach(item => {
    assert.equal(item.questionKey, matcher.questionKey(item));
    assert.equal(item.optionKey, matcher.optionKey(item.options));
    assert.notEqual(item.id, 'old-id');
  });
  assert.notEqual(upgraded.records[0].questionKey, upgraded.records[1].questionKey);
  assert.equal(oldMemory.size, 1, '不更换稳定存储键或清空旧库');

  const escaped = record({ options: [{ label: 'A', text: "'-50" }, { label: 'B', text: "'引用" }, { label: 'C', text: "''-50" }] });
  let state = await store.importFiles([file('风险管理_题库_1题.csv', csv([escaped]))], { role: '主操' });
  assert.equal(state.records[0].options[0].text, '-50');
  assert.equal(state.records[0].options[1].text, "'引用");
  assert.equal(state.records[0].options[2].text, "''-50");
  assert.equal(state.records[0].correctTexts[0], "'引用");

  state = await store.importFiles([file('风险管理.json', JSON.stringify({ title: '风险管理', sourceUrl: record().sourceUrl, questions: [{ ...record(), role: undefined }] }))], { role: '主操' });
  assert.equal(state.total, 1, '相同岗位/课程/来源的导入应替换旧数据');
  assert.equal(state.records[0].questionKey, matcher.questionKey(state.records[0]));
  assert.equal(state.records[0].optionKey, matcher.optionKey(state.records[0].options));
  state = await store.importFiles([file('班长.csv', csv([record({ course: '班长课程', sourceUrl: 'http://host/exam/leader/questions' })]))], { role: '班长' });
  assert.equal(state.total, 2, '导入一个岗位不丢失其他岗位');
  assert.equal(state.counts.主操, 1); assert.equal(state.counts.班长, 1);
  const revision = state.revision;
  await assert.rejects(store.importFiles([file('坏.csv', csv([record({ answer: 'H' })]))], { role: '主操' }), /不存在的选项/);
  assert.equal((await store.load()).revision, revision, '无效导入应保持原题库不变');
  await assert.rejects(store.importFiles([file('没有岗位.csv', csv([record()]))]), /选择主操/);
  await assert.rejects(store.importFiles([file('坏.json', JSON.stringify([record({ correctTexts: ['作业甲'] })]))]), /不一致/);
  await assert.rejects(store.importFiles([file('空.json', '{"records":[]}')]), /没有题目/);
  await store.setSetting('role', '班长');
  assert.equal(await store.getSetting('role', ''), '班长');
  assert.equal(await store.getSetting('missing', false), false);
  const reloaded = runtime('modern', memory);
  assert.equal((await reloaded.store.load()).total, 2);
  assert.equal(await reloaded.store.getSetting('role'), '班长');
  const origin = runtime('origin');
  assert.equal((await origin.store.load()).storage, 'origin');
  assert.equal((await origin.store.importFiles([file('风险管理.csv', csv([record()]))], { role: '主操' })).storage, 'origin');

  const q = record({ options: [{ label: 'A', text: '作业乙' }, { label: 'B', text: '作业丙' }, { label: 'C', text: '作业甲' }] });
  let answer = matcher.match(q, { role: '主操', course: '风险管理' }, state);
  assert.equal(answer.status, 'matched'); assert.deepEqual(Array.from(answer.correctLabels), ['A']);
  assert.equal(matcher.match({ ...q, question: q.question.replace('不应', '应') }, { role: '主操' }, state).status, 'missing');
  assert.equal(matcher.match({ ...q, options: q.options.slice(0, 2) }, { role: '主操' }, state).status, 'missing');
  assert.equal(matcher.match({ ...q, type: '多选' }, { role: '主操' }, state).status, 'missing');
  assert.equal(matcher.match(q, {}, state).status, 'unsupported');
  assert.equal(matcher.match({ ...q, questionImages: ['image.png'] }, { role: '主操' }, state).status, 'unsupported');
  assert.equal(matcher.match({ ...q, options: [q.options[0], { label: 'B', text: q.options[0].text }] }, { role: '主操' }, state).status, 'unsupported');
  assert.deepEqual(Array.from(matcher.match({ ...q, options: q.options.map(option => ({ ...option, label: option.label + '.' })) }, { role: '主操' }, state).correctLabels), ['A']);
  assert.equal(matcher.sourceIdentity('http://one:8080/clientcn/exam/risk/questions?flag=exercise'), matcher.sourceIdentity('https://two/#/clientcn/exam/risk/questions?title=风险管理&flag=exercise'));

  const conflict = store.validateRecord(record({ course: '重大危险源', sourceUrl: 'http://other/exam/danger/questions', answer: 'A' }));
  const sameAnswer = store.validateRecord(record({ number: 2, course: '课程二', sourceUrl: 'http://other/exam/another/questions' }));
  const groupedState = { records: [state.records[0], conflict, sameAnswer, state.records[1]], revision: 99 };
  assert.equal(matcher.match(q, { role: '主操' }, groupedState).status, 'conflict');
  assert.equal(matcher.match(q, { role: '主操', course: '风险管理' }, groupedState).status, 'matched');
  answer = matcher.match(q, { role: '主操', sourceUrl: 'http://new-ip:1234/#/clientcn/exam/risk/questions?flag=exercise' }, groupedState);
  assert.equal(answer.status, 'matched'); assert.equal(answer.records.length, 1);
  answer = matcher.match(q, { role: '主操', course: '重大危险源' }, groupedState);
  assert.equal(answer.status, 'matched'); assert.deepEqual(Array.from(answer.correctLabels), ['C']);
  assert.equal(matcher.search('温度', {}, groupedState).total, 0);
  assert.equal(matcher.search('', { role: '主操' }, groupedState).total, 0);
  let found = matcher.search('温度 -50.5 作业乙', { role: '主操' }, groupedState);
  assert.equal(found.total, 2, '同题同选项同答案合并，冲突答案分别展示');
  assert(found.items.every(item => item.conflict));
  assert(found.items.some(item => item.sources.length === 2));
  assert.equal(matcher.search('温度', { role: '班长' }, groupedState).total, 1);
  assert.equal(matcher.search('温度', { role: '主操', course: '风险管理' }, groupedState).items[0].conflict, false);
  assert.equal(matcher.search('温度不存在', { role: '主操' }, groupedState).total, 0);
  found = matcher.search('温度', { role: '主操', limit: 1, offset: 0 }, groupedState);
  assert.equal(found.items.length, 1); assert.equal(found.hasMore, true);
  assert.equal(matcher.search('温度', { role: '主操', limit: 1, offset: 1 }, groupedState).hasMore, false);

  const multiple = store.validateRecord(record({ type: '多选', answer: 'AC' }));
  const multipleResult = matcher.match({ ...q, type: '多选' }, { role: '主操' }, { records: [multiple], revision: 1 });
  assert.equal(multipleResult.status, 'matched');
  assert.deepEqual(Array.from(multipleResult.correctLabels), ['B', 'C']);
  assert.deepEqual(Array.from(multipleResult.correctTexts), ['作业丙', '作业甲'], '多选字母与题库原答案文字按当前网页顺序逐项对应');
  const quotaRuntime = runtime();
  await quotaRuntime.store.importFiles([file('风险管理.csv', csv([record()]))], { role: '主操' });
  quotaRuntime.environment.GM_setValue = () => { throw new Error('quota exceeded'); };
  await assert.rejects(quotaRuntime.store.importFiles([file('班长.csv', csv([record({ course: '班长课程' })]))], { role: '班长' }), /quota/);
  assert.equal((await quotaRuntime.store.load()).total, 1, '保存失败应保持可用的旧题库');

  // Calls are serialized so independently imported roles cannot overwrite each other.
  const parallelRuntime = runtime();
  await Promise.all([
    parallelRuntime.store.importFiles([file('主操.csv', csv([record()]))], { role: '主操' }),
    parallelRuntime.store.importFiles([file('班长.csv', csv([record()]))], { role: '班长' })
  ]);
  assert.equal((await parallelRuntime.store.load()).total, 2);

  // ZIP all-or-nothing replacement; lock files and unrelated metadata are ignored.
  const zip = new JSZip();
  zip.file('题库/副操/风险管理.csv', csv([record({ sourceUrl: 'http://host/exam/a/questions' })]));
  zip.file('题库/副操/~$风险管理.csv', 'broken');
  zip.file('__MACOSX/._file.csv', 'broken');
  state = await store.importFiles([file('替换.zip', await zip.generateAsync({ type: 'nodebuffer' }))]);
  assert.equal(state.total, 1); assert.equal(state.counts.副操, 1); assert.equal(state.counts.主操, 0);
  const invalidZip = new JSZip();
  invalidZip.file('题库/主操/正常.csv', csv([record()]));
  invalidZip.file('题库/班长/损坏.csv', csv([record({ answer: 'H' })]));
  await assert.rejects(store.importFiles([file('损坏.zip', await invalidZip.generateAsync({ type: 'nodebuffer' }))]), /不存在的选项/);
  assert.equal((await store.load()).total, 1);
  await assert.rejects(store.importFiles([file('题库.zip', await zip.generateAsync({ type: 'nodebuffer' })), file('一份.csv', csv([record()]))]), /只选择一个/);
  console.log('PASS 严格语义匹配与宽松搜索分离、原答案证据、旧库重算键、本地存储和原子导入、岗位隔离、换序/冲突/搜索分页');

  const realZip = path.join(rootDir, '题库.zip');
  if (fs.existsSync(realZip)) {
    const started = performance.now();
    const imported = await store.importFiles([file('题库.zip', fs.readFileSync(realZip))]);
    assert.equal(imported.total, 5520);
    assert.equal(imported.counts.主操 + imported.counts.班长 + imported.counts.副操, 5520);
    assert(imported.records.every(row => row.correctTexts.length > 0));
    const courseConflicts = matcher.search('常压罐组收料作业中', { role: '主操', limit: 100 }, imported);
    assert(courseConflicts.items.some(item => item.conflict), '真实跨课程冲突应显式显示');
    const noSource = matcher.match(courseConflicts.items.find(item => item.conflict), { role: '主操' }, imported);
    assert.equal(noSource.status, 'conflict');
    const exact = imported.records[0];
    const matched = matcher.match(exact, { role: exact.role, course: exact.course, sourceUrl: exact.sourceUrl }, imported);
    assert.equal(matched.status, 'matched');
    assert.equal(new Set(imported.records.map(item => item.sourceFile)).size, 28);
    console.log('PASS 实际题库 ZIP：28 CSV，5520 题，岗位数量 ' + JSON.stringify(imported.counts) + '；导入耗时 ' + Math.round(performance.now() - started) + ' ms');
  }

  // Parse real DOM instead of stripping bracketed numbers/difficulty with a regex.
  const { chromium } = require('playwright');
  const browser = await chromium.launch({ channel: process.env.PLAYWRIGHT_CHANNEL || 'chrome', headless: true });
  try {
    const page = await browser.newPage();
    const requests = [];
    page.on('request', request => requests.push(request.url()));
    const optionHTML = (label, text) => `<div class="pc_examtest_content_list_des"><span class="examtest_content_list_des_optionsort">${label}</span>${text}</div>`;
    const questionHTML = (stem, options, answer) => `<div class="pc_examtest_content"><div class="pc_examtest_content_question">${stem}</div>${options.map((text, index) => optionHTML(String.fromCharCode(65 + index), text)).join('')}<div class="examtest_content_answer_left">参考答案：<span class="answer">${answer}</span></div></div>`;
    await page.setContent('<div class="pc_examtest_title">DOM 元数据验证</div>' +
      questionHTML('<p>[单选] 7. 压力（2 MPa）达到（3）时，应保持Ⅰ型设备。<span class="pc_examtest_content_question_value">（2分）</span></p><div class="pc_examtest_content_question_difficulty">难度低</div>', ['MPa', 'mPa'], 'A') +
      questionHTML('[判断] 8. 设备（2分）仍须检查难度系数（3）。<span class="pc_examtest_content_question_value">（3分）</span><div class="pc_examtest_content_question_difficulty">难度中</div>', ['对', '错'], 'B') +
      questionHTML('[多选] 9. m² 和 m2 是不同写法。', ['m²', 'm2'], 'AB'));
    await page.addScriptTag({ content: fs.readFileSync(path.join(rootDir, 'question-bank-core.js'), 'utf8') });
    const extracted = await page.evaluate(() => QuestionBankCore.extract(document));
    assert.deepEqual(extracted.questions.map(item => item.number), [7, 8, 9]);
    assert.deepEqual(extracted.questions.map(item => item.type), ['单选', '判断', '多选']);
    assert.equal(extracted.questions[0].question, '压力（2 MPa）达到（3）时，应保持Ⅰ型设备。');
    assert.equal(extracted.questions[1].question, '设备（2分）仍须检查难度系数（3）。', '真正的题干括号数字及难度字样须保留');
    assert.equal(extracted.questions[2].question, 'm² 和 m2 是不同写法。', '旧版无 p 和无元数据的结构仍可解析');
    assert.equal(extracted.questions[0].options[0].text, 'MPa');
    assert.equal(extracted.questions[0].options[1].text, 'mPa');
    assert(!extracted.questions[0].questionHTML.includes('pc_examtest_content_question_value'));
    assert.equal(await page.locator('.pc_examtest_content_question_value').count(), 2, '提取只处理克隆，不能更改网页原 DOM');
    const sampleDirectory = path.join(rootDir, '网页样本', '谊安学考试');
    const sampleHTML = path.join(sampleDirectory, '谊安学.html');
    const structurePath = path.join(sampleDirectory, '题目结构.json');
    if (fs.existsSync(sampleHTML) && fs.existsSync(structurePath)) {
      const expected = JSON.parse(fs.readFileSync(structurePath, 'utf8'));
      const actual = await page.evaluate(html => QuestionBankCore.extract(QuestionBankCore.parseHTML(html)), fs.readFileSync(sampleHTML, 'utf8'));
      assert.equal(actual.total, expected.total);
      assert.equal(actual.answered, 0);
      assert.equal(actual.title, expected.title);
      assert.deepEqual(actual.questions.map(item => ({ number: item.number, type: item.type, question: item.question, options: item.options.map(option => ({ label: option.label, text: option.text })) })),
        expected.questions.map(item => ({ number: item.number, type: item.type, question: item.question, options: item.options.map(option => ({ label: option.label, text: option.text })) })));
      console.log('PASS 新考试样本 40 题：类型/题号/题干/选项与人工结构一致，分数和难度按 DOM 排除');
    }
    assert.equal(requests.length, 0, '核心提取和保存网页解析不得请求原网站');
    console.log('PASS DOM 元数据清理、括号数字保留、旧无 p 结构与原页面不变');
  } finally { await browser.close(); }
})().catch(error => { console.error(error); process.exitCode = 1; });