/**
 * 判据总入口 —— **全部跑完再算退出码**。
 *
 * 为什么不再用 `&&` 串起来：
 *
 * 原先 `npm test` 是 `a && b && c …`。这种行为有个不起眼但很贵的后果 ——
 * **前面红一条，后面全部不跑**。于是"只红了一条"看起来像"只有一个问题"，
 * 实际上后面那些判据连跑都没跑（这次就真发生了：`background` 红着，
 * `packaging` 从来没跑到过，而它正是能发现"界面改了没重打包"的那条）。
 * 换句话说：`&&` 链下的"全绿"是可信的，**"红"是不可信的**。
 *
 * 现在：每条判据都跑，红的收集起来，最后一起报、一起退出。
 *
 * 另外两条防"判据自己不会跑"的自检（与 process.exit 之后写判据是同一族问题）：
 *   1. 清单里的文件必须存在（名字写错 = 静默跳过一条判据）；
 *   2. `test/` 下的每个 `*.test.mjs` 都必须在清单里
 *      —— 这次 `cross-client-theme.test.mjs` 就是"写好了但没接进套件"，
 *      在它进套件之前一直是隐身状态。加了这条，**新增判据忘了接线会直接红**。
 *   3. 判据规范 `test/CRITERIA.md` 要在、且要点到那几条规则
 *      —— 写判据的规矩本身也会被"忘了带"（形状记在某个人的脑子里等于没有）。
 *
 * 写判据之前先读 `test/CRITERIA.md`（判结构与行为，不判字面与邻接）。
 */
import { prose } from './lib/read.mjs';
import { spawnSync } from 'node:child_process';
import { existsSync, readdirSync } from 'node:fs';
import { dirname, join } from 'node:path';
import { fileURLToPath } from 'node:url';

const HERE = dirname(fileURLToPath(import.meta.url));
const ROOT = join(HERE, '..');

/**
 * 判据清单：[文件, 额外 node 参数]。
 *
 * `--test` 给用 node:test 写的判据；鸿蒙那条要 `--experimental-strip-types`
 * 才能直接执行 `client/harmony/.../MailGrouping.ts`（判据跑的是客户端真正引用的那份逻辑）。
 */
/*
 * 自检 3：判据规范在不在、有没有写到那几条关键规则。
 *
 * 为什么把"文档"也判：`CRITERIA.md` 里的每条都是踩出来的（窗口式判据、邻接式判据、
 * 生成的清单被侵蚀、剥注释读不到理由……）。规则只在某个人的脑子里时，下一个人会重踩一遍；
 * 文件被删/被搬走却没人发现，等于规则也没了。这里只断"还在 + 关键条目还在"，
 * 不断它的措辞 —— 那是笔记，不是接口。
 */
const CRITERIA_DOC = join(HERE, 'CRITERIA.md');
if (!existsSync(CRITERIA_DOC)) {
  console.error('✗ 判据规范 test/CRITERIA.md 不见了（写判据的规矩不能只活在脑子里）');
  process.exit(1);
}
const criteriaDoc = prose(CRITERIA_DOC);
for (const must of ['配对/解析', 'allow-list', '变异验证', '剥掉注释', '按行', '自报条数', '只支撑你看到的那一层', '已经在某个提交里', '自带修法', '按 id 联接', '不要退化成对源码形状的匹配']) {
  if (!criteriaDoc.includes(must)) {
    console.error(`✗ 判据规范里少了「${must}」这条 —— 规则被删掉了还是搬走了？`);
    process.exit(1);
  }
}

const SUITE = [
  ['test/markdown-xss.test.mjs', [], 9],
  ['test/narrow-layout.test.mjs', [], 62],
  ['test/nav-merge.test.mjs', [], 8],
  ['test/theme.test.mjs', [], 30],
  ['test/background.test.mjs', [], 42],
  ['test/cross-client-theme.test.mjs', [], 15],
  ['test/harmony-logic.test.mjs', ['--experimental-strip-types', '--no-warnings'], 28],
  ['test/harmony-system-api.test.mjs', [], 5],
  // P4 外观同步：跑 model/Appearance.ts（纯逻辑），所以也要 strip-types
  ['test/harmony-appearance.test.mjs', ['--experimental-strip-types', '--no-warnings'], 24],
  // P5 悬浮玻璃导航：点击配对 / index 决定挂载 / 命中区 ≥44vp / 悬浮与让位
  ['test/harmony-nav.test.mjs', ['--experimental-strip-types', '--no-warnings'], 6],
  // 外观契约：默认值去 Go 源码里读（服务端 DefaultAppearance 是权威）+ 缓存键按账号
  ['test/appearance-defaults.test.mjs', [], 3],
  ['test/build-stamp.test.mjs', [], 6],
  ['test/packaging.test.mjs', [], 5],
  ['test/commit-hygiene.test.mjs', ['--experimental-strip-types', '--no-warnings'], 2],
  // 判据目录自身的卫生：读文本必须走 test/lib/read.mjs 的具名入口
  ['test/criteria-hygiene.test.mjs', [], 2]
];

// 自检 1：清单里的文件必须真的存在（写错名字 = 那条判据永远不跑）
const ghosts = SUITE.map(([f]) => f).filter((f) => !existsSync(join(ROOT, f)));
// 自检 2：test/ 下每个 *.test.mjs 都要在清单里（防"写好了没接线"）
const onDisk = readdirSync(join(ROOT, 'test'))
  .filter((f) => f.endsWith('.test.mjs'))
  .map((f) => `test/${f}`);
const unwired = onDisk.filter((f) => !SUITE.some(([s]) => s === f));

if (ghosts.length || unwired.length) {
  if (ghosts.length) console.error(`清单里的判据文件不存在：${ghosts.join('、')}`);
  if (unwired.length) {
    console.error(`这些判据文件没接进套件（写了却不会跑）：${unwired.join('、')}`);
  }
  process.exit(1);
}

/*
 * 自检 3：判据不得写在 `process.exit()` **之后**（pi 提议，2026-09-14）。
 *
 * 自检 1/2 管的是"文件没接线"，管不到"检查写在了退出之后" —— 而那正是实际发生过的
 * 第 4 例：4 条玻璃判据被并发写入落到了文件末尾、`process.exit()` 后面，
 * 于是**一条都不执行、也不计入通过/失败**，输出看起来完全正常。
 * 这种事的成因是结构性的（并发写入总是往文件末尾追加），所以它一定会再发生，
 * 而它下一次仍然不报错 —— 静态扫一遍最省事。
 */
const buried = [];
for (const [file, flags] of SUITE) {
  if (flags.includes('--test')) {
    continue; // node:test 那几条没有 process.exit，结构上不会踩这个
  }
  const src = prose(join(ROOT, file));
  const exitAt = src.lastIndexOf('process.exit(');
  if (exitAt >= 0 && /(^|\n)\s*check\(/.test(src.slice(exitAt))) {
    buried.push(file);
  }
}
if (buried.length) {
  console.error(`判据写在 process.exit() 之后，永远不会跑（挪到汇总之前）：${buried.join('、')}`);
  process.exit(1);
}

/*
 * 自检 4（pi 2026-09-14 提的家族，第 6 例）：**"判据自己不会跑"**。
 * 第 6 例的宿主是 runner 自己：清单里的 flag 与判据写法如果配错，症状是"看起来全绿"。
 *
 * ⚠️ 落地前先实测了两条真实样本，结论与 pi 的猜测**不同**，记在这里免得后人重猜：
 *   - `node --test <自定义 check() 的判据>`：**退出码照样传出来**（文件 exit 1 → 命令行 exit 1），
 *     并没有被 runner 吞掉；
 *   - 但 `node --test <什么都不做的文件>` 会报 `# tests 1 / # pass 1` ——
 *     **计数不是"检查跑过"的证据**。所以"解析 pass 计数、0 就判红"这条路既
 *     抓不到空判据（它报 1），又会在 `narrow-layout`（汇总行"全部通过"里没有数字）上误报。
 *
 * 换成**结构证据**：每条判据文件里必须存在"能红"的路径 ——
 * node:test 的 `test(`、自定义 `check(`、或显式 `process.exit(1)`。
 * 一个都没有 = 它永远不会红，与"全通过"长得一模一样。
 * 再加一条"跑完必须有输出"（12 条判据现在都有输出），静默成功同样可疑。
 */
function shapeOf(file) {
  const src = prose(join(ROOT, file));
  const usesNodeTest = /from 'node:test'/.test(src);
  const canFail = usesNodeTest
    || /(^|[^.\w])check\(/.test(src)
    || /process\.exit\(\s*1\s*\)/.test(src);
  return { usesNodeTest, canFail };
}

const shapeless = [];
for (const [file, flags] of SUITE) {
  if (flags.includes('--test')) {
    console.error(`清单里不要手写 --test（它由文件内容推导）：${file}`);
    process.exit(1);
  }
  if (!existsSync(join(ROOT, file))) continue; // 自检 1 已经报过了
  if (!shapeOf(file).canFail) shapeless.push(file);
}
if (shapeless.length) {
  console.error('这些判据文件里找不到任何"能红"的路径（test( / check( / process.exit(1)）：'
    + `${shapeless.join('、')} —— 它们永远不会红，与"全通过"看起来一样`);
  process.exit(1);
}

const reds = [];
for (const [file, flags, expected] of SUITE) {
  console.log(`\n========== ${file} ==========`);
  const shape = shapeOf(file);
  const all = shape.usesNodeTest ? [...flags, '--test'] : flags;
  // 收集输出再自己打回去：观感不变（stdio:'inherit' 的等价物），但能顺手做"跑了吗"的检查
  const r = spawnSync(process.execPath, [...all, join(ROOT, file)], { encoding: 'utf8' });
  const out = (r.stdout || '') + (r.stderr || '');
  process.stdout.write(r.stdout || '');
  process.stderr.write(r.stderr || '');
  // 不 break：后面每条都要跑出来，否则"红了几条"这个信息本身是假的
  if (r.status !== 0) reds.push(`${file}（退出码 ${r.status}）`);
  else if (out.trim().length === 0) reds.push(`${file}（跑完没有任何输出 —— 判据没跑起来的典型症状）`);
  else {
    /*
     * 自报条数（闭环）：自定义 check() 打 `RESULT pass=N fail=M`，node:test 打 `# pass N`。
     * 只解析**固定 marker**，不去猜口语汇总（「窄屏布局：全部通过」里没有数字，
     * 靠猜数字的写法会误报 —— pi 提过，我也先贴过真实样本）。
     */
    const marker = /RESULT pass=(\d+) fail=(\d+)/.exec(out);
    const nodeTest = /^# pass (\d+)/m.exec(out);
    const ran = marker ? Number(marker[1]) : (nodeTest ? Number(nodeTest[1]) : null);
    if (ran === null) {
      /*
       * 报错**自带修法**（pi 2026-09-14）：这条契约的受众不只是读过规范的人 ——
       * 并发写 WebUI 的 agent 新加判据时不会打开 CRITERIA.md，看到红的第一反应
       * 很可能是"套件坏了"（删自检、往清单里塞豁免）。**red 是 ta 一定会看到的东西，
       * 文档不一定会被打开** —— 所以把修法直接写进这条错误里，并给出可抄的样板。
       */
      reds.push(`${file}
      ↳ 没找到自报条数。修法（二选一）：
        1) 用共享 helper（新判据推荐）：
             import { check, finish } from './lib/checks.mjs';
             check('判据名', 条件, '失败时给人看的细节');
             finish('标签');            // 它负责打 RESULT pass=N fail=M
           样板：test/markdown-xss.test.mjs、test/narrow-layout.test.mjs
        2) 自己打一行（老写法，计数必须写在 check() 内部，否则"实现被换空"看不见）：
             console.log(\`RESULT pass=\${pass} fail=\${fail}\`);
           样板：test/theme.test.mjs、test/background.test.mjs
       （用 node:test 写的判据不用管：runner 认 \`# pass N\`。）`);
    } else if (expected > 0 && ran < expected) {
      reds.push(`${file}
      ↳ 自报 ${ran} 条 < 清单里登记的 ${expected} 条。常见成因：判据被删/被跳过（写在 process.exit() 之后、
        条件里提前 return）、check() 的实现被改坏（合并冲突）、marker 打在了汇总之前但计数没接上。
        确认确实该减少条数时，把清单里那个数字一起改掉（那是一次显式、可复核的编辑）。`);
    }
  }
}

/*
 * ─── 静态判据的**欠账**与到期机制（pi 2026-09-14 提议） ───
 *
 * 有些判据只能验**形态**（读 `.ets` 源码），因为它们要验的东西在本机跑不起来：
 * 鸿蒙侧编译要 hvigorw、运行要设备/模拟器。这类判据登记在下面，并各自写清
 * **什么前提一旦成立它就过期**。
 *
 * 为什么不能只写一句"暂时"：**"暂时"不是一种状态，是一个待办** —— 规范里写下的
 * "暂时"没有任何机制会回来读它，于是永远留在原地。这里把它变成可机检的形状：
 *   1. `UNBLOCK` 必须是**可检测的前提**（这里就是"有没有可用设备"），不是陈述；
 *   2. 汇总里打 `RESULT static=N` —— 这是**欠账余额**，涨了要看得见；
 *   3. **前提一旦为真，欠账当场变红**：不等人想起来，设备可用的那天这些判据必须
 *      改成行为判据（或明确降级并写理由）。
 *
 * 这条是"自报 0 条 < 登记条数"的**时间版本**：那条管"判据还在不在"，这条管
 * "它该升级了没有"。
 */
const PROBES = {
  device: {
    desc: '有可用的设备/模拟器（hdc 看得到目标）',
    run() {
      const sdkHdc = '/opt/huawei/command-line-tools/sdk/default/openharmony/toolchains/hdc';
      const candidates = [sdkHdc, 'hdc'];
      for (const bin of candidates) {
        try {
          const out = execFileSync(bin, ['list', 'targets'], { encoding: 'utf8', timeout: 15000 });
          const t = out.trim();
          if (t && !/\[Empty\]/.test(t)) return true;
        } catch { /* 没有 hdc 或超时：前提不成立 */ }
      }
      return false;
    }
  }
};

/** 只能验形态的判据：文件 + 为什么只能静态 + 到期前提 */
const STATIC_ONLY = [
  ['test/harmony-nav.test.mjs', '底栏结构/命中区常量/挂载关系：`.ets` 要 hvigorw 才能编译、要设备才能点', 'device'],
  ['test/harmony-appearance.test.mjs', '壁纸/令牌/遮罩渲染：观感与运行期换肤要设备', 'device'],
  ['test/harmony-logic.test.mjs', '页面状态机与文案：`.ets` 状态要跑起来才算数', 'device'],
  ['test/cross-client-theme.test.mjs', '跨端令牌与玻璃分工：一端是 `.ets`，只能静态对齐', 'device'],
  ['test/appearance-defaults.test.mjs', '默认值契约里 `.ets` 那半：运行时行为要设备', 'device']
];

for (const [file, , probe] of STATIC_ONLY) {
  if (!SUITE.some(([f]) => f === file)) {
    console.error(`✗ 静态判据登记里的 ${file} 不在套件清单里（登记要跟着套件走）`);
    process.exit(1);
  }
  if (!PROBES[probe]) {
    console.error(`✗ ${file} 的到期前提 \`${probe}\` 不是已知探针（UNBLOCK 必须是可机检的前提，不是一句陈述）`);
    process.exit(1);
  }
}
const dueStatic = STATIC_ONLY.filter(([, , probe]) => PROBES[probe].run());
if (dueStatic.length > 0) {
  console.error(`\n✗ 静态判据**到期**了：${PROBES[dueStatic[0][2]].desc} 现在是成立的 ——`);
  for (const [file, why, probe] of dueStatic) {
    console.error(`  - ${file}（到期前提：${PROBES[probe].desc}；当初只能静态的原因：${why}）`);
  }
  console.error(
    '  这些判据当时只能验形态。前提成立后必须做其中一件（别默默留着）：\n' +
    '    a) 改成**行为判据**（真跑一遍/真点一次），静态那条降级或删掉；\n' +
    '    b) 明确写"为什么仍然只能静态"（如设备能编译但点不了），并改换一个更准的到期前提。\n' +
    '  这是"暂时"的到期机制：它的作用就是不等谁想起来。'
  );
  process.exit(1);
}
console.log(`RESULT static=${STATIC_ONLY.length}（只能验形态的判据：到期前提成立就自动变红）`);

console.log(`\n========== 判据汇总 ==========`);
if (reds.length === 0) {
  console.log(`全部通过（${SUITE.length} 个判据文件：${SUITE.map(([f]) => f.replace('test/', '').replace('.test.mjs', '')).join('、')}）`);
  process.exit(0);
}
console.error(`红的判据（${reds.length}/${SUITE.length}）：`);
for (const r of reds) console.error(`  - ${r}`);
process.exit(1);