// 回归测试：「原分类」标记 + 已完成任务恢复语义
//
// v3.5+ 行为契约：
//   1. 勾选子分类里的任务 → task.originalCategory = categoryName
//   2. writer 写出时把 `[原分类：xxx]` 排在 `[▶]/[⭐]` 之后、文本之前（标记块内）
//   3. parser 再读回来时能把 `[原分类：xxx]` 抽到 task.originalCategory
//   4. 取消勾选：原分类还在 → 直接归位（不再回「未分类」），归位后清掉 originalCategory
//   5. 取消勾选：原分类丢失（删除 / 改名） → toggleTask 返回 restoreHint.kind === 'picker'
//   6. 取消勾选：没有 originalCategory 记录（兜底） → 直接去「未分类」，不弹窗
//   7. 拖拽任务到「已完成任务」分类 → 同样记录 originalCategory
//   8. 旧文件升级迁移：散落的 [✓] 任务搬到「已完成」时自动记 cat.name
//   9. v3.5.1+：恢复后清掉 originalCategory，文件里不出现 `[原分类：xxx] 任务` 噪音
//   10. v3.5.1+：原分类标记仅在「已完成任务」「回收站」分类里输出（writer 护栏）
//   11. v3.5.1+：moveTask 把任务移出「已完成」到普通子分类时清 originalCategory
//   12. v3.5.1+：restoreTask 从回收站恢复到普通子分类时清 originalCategory
//
// v3.5.2+ 行为契约（[18] 节）：
//   13. deleteTask / batchDeleteTasks 把任务移到 trash 时同步记录 originalCategory
//       （与 toggleTask 把任务移到「已完成任务」时记 originalCategory 对称）
//   14. restoreTask 默认（无 toCategoryName）走 _resolveRestoreTarget：
//       - 原分类还在 → category 分支，直接归位
//       - 原分类丢失 → picker 分支，返回 restoreHint，任务**仍留在 trash**
//       - 无 originalCategory 记录 → fallback 分支，落「未分类」
//   15. picker 路径下 UI 调 restoreTask(taskId, picked) 完成归位 + 清 originalCategory
//   16. 已完成任务的 originalCategory 在 deleteTask 进 trash 时不被覆盖（沿用 toggle 时的值）
//
// 跑法：node scripts/check-original-category.mjs

import {
  TaskStore,
  parseImportLine
} from '../src/task-store.js';
import { check, ok, bad, summary, printSummary } from './_lib/check.mjs';
import { makeStore } from './_lib/store-fixture.mjs';
import {
  parseMarkdown,
  CategoryKind,
  extractInlineMarkers
} from '../src/markdown-parser.js';
import { writeMarkdown } from '../src/markdown-writer.js';

// 往返：serialize 出来再 parse 回来，断言文件层的行为
function roundTrip(store) {
  return parseMarkdown(store.serialize());
}

function findCat(categories, name) {
  return categories.find(c => c.name === name) || null;
}

const BASE_DOC = `# 全部任务

## 工作

- [ ] 写周报

## 学习

- [ ] 看 Rust 入门

## 未分类

- [ ] 杂事
`;

// ============================================================
// [1] extractInlineMarkers：解析 [原分类：xxx] 标记
// ============================================================
console.log('\n[1] extractInlineMarkers 解析 [原分类：xxx] 标记');

{
  const r1 = extractInlineMarkers('[原分类：工作] 给妈妈买生日礼物');
  check('行首 [原分类：xxx] 被识别为 originalCategory',
    r1.originalCategory === '工作' && r1.text === '给妈妈买生日礼物',
    `originalCategory=${r1.originalCategory}, text=${r1.text}`);

  const r2 = extractInlineMarkers('看 Rust 入门 [原分类：学习]');
  check('行尾 [原分类：xxx] 被识别为 originalCategory',
    r2.originalCategory === '学习' && r2.text === '看 Rust 入门',
    `originalCategory=${r2.originalCategory}, text=${r2.text}`);

  const r3 = extractInlineMarkers('[▶] [⭐] 写季度汇报 [原分类：工作]');
  check('[原分类：xxx] 与 [▶]/[⭐] 共存时都正确抽取',
    r3.originalCategory === '工作' && r3.current && r3.important && r3.text === '写季度汇报',
    `orig=${r3.originalCategory}, curr=${r3.current}, imp=${r3.important}, text=${r3.text}`);

  const r4 = extractInlineMarkers('普通任务');
  check('没有标记时 originalCategory === null',
    r4.originalCategory === null,
    `originalCategory=${r4.originalCategory}`);

  const r5 = extractInlineMarkers('任务中含 [原分类：工作] 字面字符串');
  check('行中的 [原分类：xxx] 不被误识为标记',
    r5.originalCategory === null && r5.text.includes('任务中含'),
    `originalCategory=${r5.originalCategory}`);
}

// ============================================================
// [2] 勾选任务 → originalCategory 记录源分类
// ============================================================
console.log('\n[2] 勾选任务 → originalCategory 记录源分类');

{
  const store = makeStore(BASE_DOC);
  const workCat = store.getCategory('工作');
  const task = workCat.tasks.find(t => t.text === '写周报');
  const result = store.toggleTask('工作', task.id);

  check('toggleTask 返回 { ok: true }', result && result.ok === true);
  check('任务已从「工作」分类移除',
    !store.getCategory('工作').tasks.some(t => t.text === '写周报'));
  check('任务已到「已完成任务」分类',
    store.getCategory('已完成任务').tasks.some(t => t.text === '写周报'));
  check('task.originalCategory === "工作"',
    store.getCategory('已完成任务').tasks[0].originalCategory === '工作',
    `actual=${store.getCategory('已完成任务').tasks[0].originalCategory}`);
  check('task.completed === true',
    store.getCategory('已完成任务').tasks[0].completed === true);
}

// ============================================================
// [3] writer 把 [原分类：xxx] 排在 [▶]/[⭐] 之后、文本之前
// ============================================================
console.log('\n[3] writer 写出 [原分类：xxx]');

{
  const store = makeStore(BASE_DOC);
  const workCat = store.getCategory('工作');
  const task = workCat.tasks.find(t => t.text === '写周报');
  store.toggleTask('工作', task.id);

  const md = store.serialize();
  check('serialize 输出含 [原分类：工作]',
    md.includes('[原分类：工作]'),
    `output 前 400 字: ${md.slice(0, 400)}`);
  check('serialize 输出仍是 [✓] 勾选态',
    md.includes('- [✓]') && md.includes('写周报'));
  // v3.5+：[原分类：xxx] 排在标记块内（[▶]/[⭐] 之后、文本之前）
  // 验证：写出行形如 `- [✓] [原分类：工作] 写周报`（写在本行的「已完成任务」分类下）
  const completedLine = md.split('\n').find(l => l.includes('写周报') && l.includes('[✓]'));
  check('原分类标记排在文本之前（标记块内）',
    completedLine && /\[原分类：工作\]\s+写周报/.test(completedLine),
    `line: ${completedLine}`);
}

// ============================================================
// [4] Markdown 往返：parse → 仍然带 originalCategory
// ============================================================
console.log('\n[4] Markdown 往返 —— 解析回来仍带 originalCategory');

{
  const store = makeStore(BASE_DOC);
  const workCat = store.getCategory('工作');
  const task = workCat.tasks.find(t => t.text === '写周报');
  store.toggleTask('工作', task.id);

  // 重新 parse 自己 serialize 出来的 markdown，模拟"保存后再加载"
  const categories = roundTrip(store);
  const completed = findCat(categories, '已完成任务');
  const reloaded = completed?.tasks.find(t => t.text === '写周报');

  check('往返后任务仍在「已完成任务」',
    !!reloaded);
  check('往返后 task.originalCategory 仍为 "工作"',
    reloaded?.originalCategory === '工作',
    `actual=${reloaded?.originalCategory}`);
  check('往返后 task.completed === true',
    reloaded?.completed === true);
}

// ============================================================
// [5] 取消勾选：原分类还在 → 直接归位
// ============================================================
console.log('\n[5] 取消勾选：原分类还在 → 直接归位');

{
  const store = makeStore(BASE_DOC);
  const workCat = store.getCategory('工作');
  const task = workCat.tasks.find(t => t.text === '写周报');
  store.toggleTask('工作', task.id);  // 勾选
  const result = store.toggleTask('已完成任务', task.id);  // 取消勾选

  check('取消勾选返回 restoreHint.kind === "category"',
    result && result.restoreHint && result.restoreHint.kind === 'category',
    `restoreHint=${JSON.stringify(result?.restoreHint)}`);
  check('取消勾选后任务回到「工作」子分类',
    store.getCategory('工作').tasks.some(t => t.text === '写周报'));
  check('任务不再在「已完成任务」里',
    !store.getCategory('已完成任务').tasks.some(t => t.text === '写周报'));
  check('任务 completed === false',
    store.getCategory('工作').tasks.find(t => t.text === '写周报').completed === false);
  // v3.5.1：恢复后清掉 originalCategory —— 任务已回到「工作」里，再保留标记就是噪音
  check('恢复后 task.originalCategory === null',
    store.getCategory('工作').tasks.find(t => t.text === '写周报').originalCategory === null);
  check('恢复后 serialize 不含 [原分类：工作]',
    !store.serialize().includes('[原分类：工作]'));
}

// ============================================================
// [6] 取消勾选：原分类丢失 → restoreHint.kind === 'picker'
// ============================================================
console.log('\n[6] 取消勾选：原分类丢失（删除） → 弹窗提示');

{
  const store = makeStore(BASE_DOC);
  const workCat = store.getCategory('工作');
  const task = workCat.tasks.find(t => t.text === '写周报');
  store.toggleTask('工作', task.id);  // 勾选，记录原分类 = "工作"

  // 删除「工作」子分类 —— 模拟用户改了名或删了
  store.deleteCategory('工作');

  const result = store.toggleTask('已完成任务', task.id);  // 取消勾选

  check('原分类丢失时 restoreHint.kind === "picker"',
    result && result.restoreHint && result.restoreHint.kind === 'picker',
    `restoreHint=${JSON.stringify(result?.restoreHint)}`);
  check('restoreHint.missing === "工作"',
    result && result.restoreHint && result.restoreHint.missing === '工作',
    `missing=${result?.restoreHint?.missing}`);
  check('store.restoreCompletedTask 能把任务放到指定分类',
    store.restoreCompletedTask(task.id, '学习') &&
    store.getCategory('学习').tasks.some(t => t.text === '写周报'));
  // v3.5.1：picker 路径恢复后同样清掉 originalCategory
  check('picker 路径恢复后 task.originalCategory === null',
    store.getCategory('学习').tasks.find(t => t.text === '写周报').originalCategory === null);
  check('picker 路径恢复后 serialize 不含 [原分类：工作]',
    !store.serialize().includes('[原分类：工作]'));
}

// ============================================================
// [7] 取消勾选：没有 originalCategory → 直接去「未分类」
// ============================================================
console.log('\n[7] 取消勾选：没有 originalCategory 记录 → 直接去「未分类」');

{
  const store = makeStore(BASE_DOC);
  const workCat = store.getCategory('工作');
  const task = workCat.tasks.find(t => t.text === '写周报');

  // 手动设置：勾选但不记 originalCategory（模拟"很旧的文件"）
  store.toggleTask('工作', task.id);
  // 抹掉 originalCategory 模拟"旧版没有这个字段"
  const completedTask = store.getCategory('已完成任务').tasks[0];
  completedTask.originalCategory = null;

  const result = store.toggleTask('已完成任务', task.id);  // 取消勾选

  check('restoreHint.kind === "fallback"',
    result && result.restoreHint && result.restoreHint.kind === 'fallback',
    `restoreHint=${JSON.stringify(result?.restoreHint)}`);
  check('任务落到「未分类」',
    store.getCategory('未分类').tasks.some(t => t.text === '写周报'));
  check('restoreHint 不带 missing（不是 picker）',
    !result.restoreHint.missing);
}

// ============================================================
// [8] 拖入「已完成任务」分类 → 同样记录 originalCategory
// ============================================================
console.log('\n[8] 拖入「已完成任务」→ 同样记录 originalCategory');

{
  const store = makeStore(BASE_DOC);
  const workCat = store.getCategory('工作');
  const task = workCat.tasks.find(t => t.text === '写周报');

  // 通过 moveTask 拖入「已完成任务」（拖到 completed 分类，自动 completed=true）
  store.moveTask('工作', task.id, '已完成任务');

  const t = store.getCategory('已完成任务').tasks.find(x => x.text === '写周报');
  check('拖入后任务在「已完成任务」',
    !!t);
  check('拖入后 originalCategory === "工作"',
    t && t.originalCategory === '工作',
    `actual=${t?.originalCategory}`);
  check('拖入后 completed === true',
    t && t.completed === true);
}

// ============================================================
// [9] 旧文件升级迁移：散落的 [✓] 任务搬到「已完成」时记原分类
// ============================================================
console.log('\n[9] 旧文件升级迁移：散落的 [✓] 任务自动记原分类');

{
  // 模拟 v3.4 之前的旧文件：散落的 [✓] 任务在子分类里
  const OLD_DOC = `# 全部任务

## 工作

- [ ] 写周报
- [✓] 买牛奶

## 学习

- [✓] 看 Rust 入门

## 未分类

- [ ] 杂事
`;
  const store = makeStore(OLD_DOC);

  // 触发迁移（loadFromContent 已经跑过；这里再调一次确认幂等）
  // store._migrateCompletedTasksToCategory();

  const completed = store.getCategory('已完成任务');
  const workTask = completed.tasks.find(t => t.text === '买牛奶');
  const studyTask = completed.tasks.find(t => t.text === '看 Rust 入门');

  check('旧文件的 [✓] 任务都搬到了「已完成任务」',
    workTask && studyTask);
  check('「工作」来源的任务 originalCategory === "工作"',
    workTask && workTask.originalCategory === '工作',
    `actual=${workTask?.originalCategory}`);
  check('「学习」来源的任务 originalCategory === "学习"',
    studyTask && studyTask.originalCategory === '学习',
    `actual=${studyTask?.originalCategory}`);

  // 文件层验证：serialize 后能看到 [原分类：xxx]
  const md = store.serialize();
  check('serialize 后含 [原分类：工作]',
    md.includes('[原分类：工作]'));
  check('serialize 后含 [原分类：学习]',
    md.includes('[原分类：学习]'));
}

// ============================================================
// [10] batchToggleCompleted：批量取消勾选也走 _resolveRestoreTarget
// ============================================================
console.log('\n[10] 批量取消勾选：每条任务归到各自原分类');

{
  const store = makeStore(BASE_DOC);
  const workCat = store.getCategory('工作');
  const studyCat = store.getCategory('学习');
  const workTask = workCat.tasks.find(t => t.text === '写周报');
  const studyTask = studyCat.tasks.find(t => t.text === '看 Rust 入门');

  // 批量勾选
  store.batchToggleCompleted([
    { categoryName: '工作', taskId: workTask.id },
    { categoryName: '学习', taskId: studyTask.id }
  ], true);

  check('批量勾选后两条都在「已完成任务」',
    store.getCategory('已完成任务').tasks.length === 2);

  // 批量取消勾选
  const completed = store.getCategory('已完成任务');
  const t1 = completed.tasks.find(t => t.text === '写周报');
  const t2 = completed.tasks.find(t => t.text === '看 Rust 入门');
  store.batchToggleCompleted([
    { categoryName: '已完成任务', taskId: t1.id },
    { categoryName: '已完成任务', taskId: t2.id }
  ], false);

  check('「写周报」回到「工作」',
    store.getCategory('工作').tasks.some(t => t.text === '写周报'));
  check('「看 Rust 入门」回到「学习」',
    store.getCategory('学习').tasks.some(t => t.text === '看 Rust 入门'));
  // v3.5.1：批量恢复后也清掉 originalCategory
  check('批量恢复后「写周报」originalCategory === null',
    store.getCategory('工作').tasks.find(t => t.text === '写周报').originalCategory === null);
  check('批量恢复后「看 Rust 入门」originalCategory === null',
    store.getCategory('学习').tasks.find(t => t.text === '看 Rust 入门').originalCategory === null);
  check('批量恢复后 serialize 不含 [原分类：xxx]',
    !store.serialize().match(/\[原分类：/));
}

// ============================================================
// [11] parseImportLine：导入对话框也支持 [原分类：xxx]
// ============================================================
console.log('\n[11] parseImportLine 支持 [原分类：xxx]');

{
  const r1 = parseImportLine('- [ ] 看牙医 [原分类：生活]');
  check('parseImportLine 把 [原分类：xxx] 抽到 originalCategory',
    r1 && r1.originalCategory === '生活' && r1.text === '看牙医',
    `originalCategory=${r1?.originalCategory}, text=${r1?.text}`);
}

// ============================================================
// [12] CategoryKind.COMPLETED 不会被误认为恢复目标
// ============================================================
console.log('\n[12] kind=COMPLETED 的分类不能作为恢复目标');

{
  const store = makeStore(BASE_DOC);
  // 手动注入一个恶意分类（虽然实际不会发生，但要防御）
  store.categories.push({
    name: '陷阱',
    kind: CategoryKind.COMPLETED,  // 故意是 COMPLETED
    isSpecial: true,
    parentOtherTasks: false,
    tasks: []
  });

  const workCat = store.getCategory('工作');
  const task = workCat.tasks.find(t => t.text === '写周报');
  store.toggleTask('工作', task.id);

  // 把"工作"删了，但有个 kind=COMPLETED 的同名陷阱分类
  store.deleteCategory('工作');
  // 改名为「工作」（让它跟 originalCategory 同名）
  const trap = store.categories.find(c => c.name === '陷阱');
  trap.name = '工作';

  const result = store.toggleTask('已完成任务', task.id);
  // 应该返回 picker，因为同名"工作"分类是 COMPLETED 类型，不能作为恢复目标
  check('kind=COMPLETED 的同名分类不作为恢复目标',
    result && result.restoreHint && result.restoreHint.kind === 'picker',
    `restoreHint=${JSON.stringify(result?.restoreHint)}`);
}

// ============================================================
// [13] v3.5.1+：原分类标记仅在「已完成 / 回收站」分类里输出（writer 护栏）
// ============================================================
console.log('\n[13] writer 护栏：原分类标记仅在 COMPLETED/TRASH 输出');

{
  const store = makeStore(BASE_DOC);
  const workCat = store.getCategory('工作');
  const studyCat = store.getCategory('学习');
  const workTask = workCat.tasks.find(t => t.text === '写周报');
  const studyTask = studyCat.tasks.find(t => t.text === '看 Rust 入门');

  // 1. 勾选一条 → 进入已完成 → 出现 [原分类：工作]
  store.toggleTask('工作', workTask.id);
  // 2. 把另一条拖到已完成 → 同样记录
  store.moveTask('学习', studyTask.id, '已完成任务');

  const md = store.serialize();
  // 文件里 [原分类：工作] 出现在「已完成任务」段 ✓
  const completedSection = md.split('# 已完成任务')[1] || '';
  check('writer 在「已完成任务」段写出 [原分类：工作]',
    completedSection.includes('[原分类：工作]'));
  check('writer 在「已完成任务」段写出 [原分类：学习]',
    completedSection.includes('[原分类：学习]'));

  // 3. 通过 moveTask 把已完成任务拖回普通子分类 → originalCategory 清掉
  const completedTask = store.getCategory('已完成任务').tasks[0];
  store.moveTask('已完成任务', completedTask.id, '生活');

  // 4. 验证「生活」段不出现 [原分类：xxx]
  const lifeSection = md.split('# 生活')[1]?.split('\n')[0]; // 旧 md 无生活内容
  // 重新 serialize（因为 moveTask 后 md 应该变了）
  const mdAfter = store.serialize();
  // 「生活」分类下不该出现 [原分类：xxx]
  const lifeIndex = mdAfter.indexOf('## 生活');
  const uncategorizedIndex = mdAfter.indexOf('## 未分类');
  const lifeSectionNew = mdAfter.slice(lifeIndex, uncategorizedIndex > 0 ? uncategorizedIndex : undefined);
  check('moveTask 把已完成任务拖回普通子分类后，那条任务没 [原分类：xxx]',
    !lifeSectionNew.includes('[原分类：'),
    `life section: ${lifeSectionNew.slice(0, 200)}`);
}

// ============================================================
// [14] moveTask 跨普通子分类：原始 originalCategory 保持（防御性无侵入）
// ============================================================
console.log('\n[14] moveTask 普通子分类之间互拖 → originalCategory 不受影响');

{
  const store = makeStore(BASE_DOC);
  const workCat = store.getCategory('工作');
  const task = workCat.tasks.find(t => t.text === '写周报');
  // 故意设 originalCategory（外部编辑 / 解析器的产物）
  task.originalCategory = '工作';
  // 从「工作」拖到「学习」
  store.moveTask('工作', task.id, '学习');

  const moved = store.getCategory('学习').tasks.find(t => t.text === '写周报');
  // v3.5.1 进入 NORMAL 路径会清掉 originalCategory（即便它本来就被外部设了）
  check('普通子分类之间 moveTask 后 originalCategory === null',
    moved && moved.originalCategory === null,
    `actual=${moved?.originalCategory}`);
}

// ============================================================
// [15] restoreTask：从回收站恢复到普通子分类 → 清 originalCategory（防御）
// ============================================================
console.log('\n[15] restoreTask 回收站 → 普通子分类 → 清 originalCategory');

{
  const store = makeStore(BASE_DOC);
  const workCat = store.getCategory('工作');
  const task = workCat.tasks.find(t => t.text === '写周报');
  // 勾选 → 进已完成（带 originalCategory）→ 删 → 进回收站（保留状态）
  store.toggleTask('工作', task.id);
  store.deleteTask('已完成任务', task.id);

  const trashed = store.getCategory('回收站').tasks[0];
  // 模拟"防御性原始数据"：外部编辑设了 originalCategory（即使 completed=true 在 trash 里也罕见）
  // 这里直接用 deleteTask 后的状态：task.completed=true 且 task.originalCategory='工作'
  check('删除已完成任务后，回收站里 originalCategory 仍在',
    trashed && trashed.originalCategory === '工作' && trashed.completed === true);

  // 恢复到「学习」子分类
  const ok = store.restoreTask(trashed.id, '学习');
  // restoreTask 看到 taskSnapshot.completed=true 会重投到「已完成任务」—— 不进 NORMAL 路径
  // 这条路径下 originalCategory 应该保留
  const finalTask = store.getCategory('学习').tasks.find(t => t.text === '写周报')
    || store.getCategory('已完成任务').tasks.find(t => t.text === '写周报');
  if (ok && finalTask) {
    const inCompleted = store.getCategory('已完成任务').tasks.some(t => t.text === '写周报');
    if (inCompleted) {
      check('completed 任务从回收站恢复后重投「已完成」→ originalCategory 保留',
        finalTask.originalCategory === '工作',
        `actual=${finalTask.originalCategory}`);
    } else {
      check('非 completed 任务从回收站恢复到普通分类 → originalCategory === null',
        finalTask.originalCategory === null,
        `actual=${finalTask.originalCategory}`);
    }
  }
}

// ============================================================
// [16] writer 防御性：即便普通子分类任务的 originalCategory 被外部塞了，写出也不带标记
// ============================================================
console.log('\n[16] writer 防御性护栏：普通子分类不写 [原分类：xxx]');

{
  // 模拟外部手工编辑：把 [原分类：xxx] 强行写到普通子分类任务里
  const DIRTY_DOC = `# 全部任务

## 工作

- [ ] [原分类：生活] 写周报

## 学习

- [ ] 看 Rust 入门
`;
  const store = makeStore(DIRTY_DOC);
  const md = store.serialize();
  // 普通子分类下不应该出现 [原分类：xxx]（writer 护栏）
  const workSection = md.split('## 工作')[1]?.split('##')[0] || '';
  check('writer 护栏：普通子分类不输出 [原分类：xxx]',
    !workSection.includes('[原分类：'),
    `work section: ${workSection.slice(0, 200)}`);
}

// ============================================================
// [17] 回收站里仍可看到 [原分类：xxx]（用户要求：回收站也是特殊分类，原分类有信息价值）
// ============================================================
console.log('\n[17] 回收站里保留 [原分类：xxx]');

{
  const store = makeStore(BASE_DOC);
  const workCat = store.getCategory('工作');
  const task = workCat.tasks.find(t => t.text === '写周报');
  // 勾选 → 已完成 → 删 → 回收站
  store.toggleTask('工作', task.id);
  store.deleteTask('已完成任务', task.id);

  const md = store.serialize();
  const trashSection = md.split('# 回收站')[1] || '';
  check('回收站段保留 [原分类：工作]',
    trashSection.includes('[原分类：工作]'),
    `trash section: ${trashSection.slice(0, 200)}`);
}

// ============================================================
// [18] v3.5.2+：回收站学「已完成任务」的 [原分类：] 语义 + 默认归位
//
// 行为契约：
//   1) deleteTask 从普通子分类搬到 trash → 自动写 originalCategory
//   2) writer 在「# 回收站」段同步写出 [原分类：xxx]
//   3) restoreTask 默认（无 toCategoryName）命中原分类 → 直接归位
//   4) restoreTask 默认 原分类丢失 → 返回 picker hint，任务**仍留在 trash**
//   5) picker 路径后续 restoreTask(taskId, picked) 完成归位 + 清掉 originalCategory
//   6) batchDeleteTasks 也写 originalCategory（与单条 deleteTask 对称）
//   7) 已完成任务从「已完成任务」删到 trash，原分类不被覆盖（沿用 toggle 时记下的）
// ============================================================
console.log('\n[18] 回收站学「已完成任务」的 [原分类：] + 默认归位');

{
  // 18.1) 普通子分类删除 → 回收站里 originalCategory 已被记下
  const store = makeStore(BASE_DOC);
  const workCat = store.getCategory('工作');
  const task = workCat.tasks.find(t => t.text === '写周报');
  store.deleteTask('工作', task.id);

  const trashed = store.getTrashCategory().tasks[0];
  check('普通子分类删除后回收站里 originalCategory === "工作"',
    trashed && trashed.originalCategory === '工作',
    `actual=${trashed?.originalCategory}`);

  // 18.2) writer 在「# 回收站」段输出 [原分类：工作]
  const md = store.serialize();
  const trashSection = md.split('# 回收站')[1] || '';
  check('writer 在「# 回收站」段写出 [原分类：工作]（trash 端到端链路打通）',
    trashSection.includes('[原分类：工作]'),
    `trash section: ${trashSection.slice(0, 200)}`);

  // 18.3) 默认 restoreTask 走 category 分支：归到「工作」
  const result = store.restoreTask(task.id);
  check('默认 restoreTask 返回 { ok: true, restored: true }',
    result.ok === true && result.restored === true,
    `result=${JSON.stringify(result)}`);
  check('restoreHint.kind === "category" + 带 targetName="工作"',
    result.restoreHint && result.restoreHint.kind === 'category' &&
      result.restoreHint.targetName === '工作',
    `restoreHint=${JSON.stringify(result.restoreHint)}`);
  check('任务归到原分类「工作」',
    store.getCategory('工作').tasks.some(t => t.text === '写周报'),
    `work tasks: ${store.getCategory('工作').tasks.map(t => t.text)}`);
  check('回收站空',
    store.getTrashCategory().tasks.length === 0);
}

{
  // 18.4) 原分类丢失 → picker hint，任务仍留在 trash
  const store = makeStore(BASE_DOC);
  const workCat = store.getCategory('工作');
  const task = workCat.tasks.find(t => t.text === '写周报');
  store.deleteTask('工作', task.id);   // record originalCategory='工作'
  store.deleteCategory('工作');        // 原分类丢失

  // 此时任务在 trash，originalCategory='工作' 但 '工作' 已不存在
  const result = store.restoreTask(task.id);
  check('原分类丢失时 restoreTask 返回 picker hint',
    result && result.restoreHint && result.restoreHint.kind === 'picker',
    `result=${JSON.stringify(result)}`);
  check('picker hint.missing === "工作"',
    result.restoreHint && result.restoreHint.missing === '工作',
    `missing=${result.restoreHint?.missing}`);
  check('picker 路径下任务**仍留在 trash**（不动任务）',
    store.getTrashCategory().tasks.length === 1 &&
    store.getTrashCategory().tasks[0].text === '写周报',
    `trash: ${store.getTrashCategory().tasks.map(t => t.text)}`);

  // 18.5) picker 选定后调 restoreTask(taskId, picked) 完成移动 + 清 originalCategory
  const r2 = store.restoreTask(task.id, '学习');
  check('picker 后续 restoreTask(id, "学习") 完成归位',
    r2.ok === true && r2.restored === true &&
      store.getCategory('学习').tasks.some(t => t.text === '写周报'),
    `r2=${JSON.stringify(r2)}, study=${store.getCategory('学习').tasks.map(t => t.text)}`);
  const moved = store.getCategory('学习').tasks.find(t => t.text === '写周报');
  check('picker 路径恢复后 task.originalCategory === null（已"回家"）',
    moved && moved.originalCategory === null,
    `actual=${moved?.originalCategory}`);
}

{
  // 18.6) batchDeleteTasks 也写 originalCategory
  const store = makeStore(BASE_DOC);
  const workCat = store.getCategory('工作');
  const studyCat = store.getCategory('学习');
  const t1 = workCat.tasks.find(t => t.text === '写周报');
  const t2 = studyCat.tasks.find(t => t.text === '看 Rust 入门');
  store.batchDeleteTasks([
    { categoryName: '工作', taskId: t1.id },
    { categoryName: '学习', taskId: t2.id }
  ]);
  const trash = store.getTrashCategory().tasks;
  check('batchDeleteTasks 后回收站里两条任务都带 originalCategory',
    trash.length === 2 &&
    trash.some(t => t.text === '写周报' && t.originalCategory === '工作') &&
    trash.some(t => t.text === '看 Rust 入门' && t.originalCategory === '学习'),
    `trash: ${trash.map(t => `${t.text}(${t.originalCategory})`).join(', ')}`);
}

{
  // 18.7) 已完成任务删到 trash，originalCategory 不被覆盖
  const store = makeStore(BASE_DOC);
  const studyCat = store.getCategory('学习');
  const task = studyCat.tasks.find(t => t.text === '看 Rust 入门');
  // 勾选 → toggleTask 写 originalCategory='学习'
  store.toggleTask('学习', task.id);
  check('toggleTask 已写 originalCategory === "学习"（前置）',
    store.getCategory('已完成任务').tasks[0].originalCategory === '学习');

  // 删 → 进入 trash，originalCategory 应保持 '学习'（不被 deleteTask 覆盖）
  store.deleteTask('已完成任务', task.id);
  const trashed = store.getTrashCategory().tasks[0];
  check('completed 任务从「已完成任务」删到 trash → originalCategory 仍为"学习"（不重写）',
    trashed && trashed.originalCategory === '学习' && trashed.completed === true,
    `actual=${trashed?.originalCategory}, completed=${trashed?.completed}`);
}

console.log(`\n结果：通过 ${summary.pass} / 失败 ${summary.fail}`);
process.exit(summary.fail === 0 ? 0 : 1);