#!/usr/bin/env node
'use strict';

const fs = require('fs');
const path = require('path');

function parseArgs(argv) {
  const args = { caseDir: '', fixture: '', envFile: '', require: '', json: false, markdown: false };
  for (let i = 2; i < argv.length; i++) {
    const a = argv[i];
    if (a === '--case-dir' || a === '--dir' || a === '-d') args.caseDir = argv[++i] || '';
    else if (a === '--fixture') args.fixture = argv[++i] || '';
    else if (a === '--env-file') args.envFile = argv[++i] || '';
    else if (a === '--require') args.require = argv[++i] || '';
    else if (a === '--json') args.json = true;
    else if (a === '--markdown') args.markdown = true;
    else if (a === '--help' || a === '-h') args.help = true;
    else throw new Error(`未知参数：${a}`);
  }
  if (!args.json && !args.markdown) args.markdown = true;
  return args;
}

function usage() {
  return `用法：
  node scripts/check_fingerprint_fixture.js --case-dir case --require canvas,webgl --markdown
  node scripts/check_fingerprint_fixture.js --fixture case/fixtures/fingerprint.fixture.json --env-file case/result/src/env/fingerprint-env.js --json

说明：检查浏览器指纹 fixture 是否覆盖 Canvas / WebGL / WebGPU / Audio / DOM 几何等终端 API，是否绑定同一 fingerprint baseline，并检查最终 env 是否避免 node-canvas / headless-gl / 自动化浏览器等错误方向。`;
}

function exists(p) { try { fs.accessSync(p); return true; } catch { return false; } }
function stat(p) { try { return fs.statSync(p); } catch { return null; } }
function readText(p) { return fs.readFileSync(p, 'utf8').replace(/^\uFEFF/, ''); }
function readJson(p) { return JSON.parse(readText(p)); }
function rel(root, p) { return (path.relative(root, p) || '.').replace(/\\/g, '/'); }
function ext(p) { return path.extname(p).toLowerCase(); }

function walk(p, out = []) {
  if (!exists(p)) return out;
  const st = stat(p);
  if (!st) return out;
  if (st.isDirectory()) {
    let names = [];
    try { names = fs.readdirSync(p); } catch { names = []; }
    for (const name of names) walk(path.join(p, name), out);
  } else if (st.isFile()) out.push(p);
  return out;
}

function countArray(v) { return Array.isArray(v) ? v.length : 0; }
function hasResultObject(v) { return !!v && typeof v === 'object' && Object.prototype.hasOwnProperty.call(v, 'result'); }
function pickBaselineId(obj) {
  if (!obj || typeof obj !== 'object') return '';
  return String(obj.baselineId || (obj.source && obj.source.baselineId) || '');
}


const BAD_VALUE_SOURCE_RE = /(AI\s*(?:推断|猜|生成|guess)|猜测|编造|伪造|默认值|随机值|mock|fake|placeholder|static\s*analysis|静态分析|inferred|guessed|random\s*value|jsdom|node-canvas|headless-gl)/i;
const REAL_VALUE_SOURCE_RE = /(RuyiTrace|NDJSON|ruyiPage|Camoufox|CloakBrowser|手动|真实浏览器|browser|Hook|HAR|MCP|用户提供|console|network)/i;
const TRACE_TOOL_RE = /(RuyiTrace|NDJSON)/i;
const AUTOMATION_OR_USER_TOOL_RE = /(ruyiPage|Camoufox|CloakBrowser|手动|真实浏览器|browser|Hook|HAR|MCP|用户提供|console|network)/i;
const LONG_VALUE_THRESHOLD = 3900;
const BAD_TRUNCATED_KEY_RE = /^(visiblePreview|visibleSha256|sha256OfVisible|visibleValue|visibleSnippet|preview|clippedPreview)$/i;
const BAD_TRUNCATED_TEXT_RE = /(\.\.\.<(?:clipped|truncated)>|<clipped>|<truncated>|__ruyiTraceLongString__|sha256OfVisible|visibleSha256|visiblePreview|realLength["']?\s*[:=]\s*["']?unknown)/i;
const CHUNK_ENCODING_RE = /^(string-chunks|base64-chunks)$/;

function jsonText(v) {
  try { return JSON.stringify(v || {}); } catch { return String(v || ''); }
}

function sourceLabel(source) {
  if (!source || typeof source !== 'object') return '';
  return [source.capturedBy, source.tool, source.mode, source.sourceType, source.type, source.origin, source.evidence]
    .filter(Boolean).map(String).join(' ');
}

function traceStatusOf(source, record) {
  return String((record && record.traceStatus) || (source && source.traceStatus) || '');
}

function hasSourceMeta(source) {
  if (!source || typeof source !== 'object') return false;
  return !!(source.capturedBy || source.tool || source.mode || source.sourceType || source.type || source.origin || source.evidence);
}

function isTruncatedTraceStatus(status) {
  const s = String(status || '');
  if (/used-untruncated|untruncated|not-truncated/i.test(s)) return false;
  return /(^|[-_\s])truncated($|[-_\s])|疑似截断|截断/i.test(s);
}

function isTraceValueSource(source, record) {
  const status = traceStatusOf(source, record);
  const label = sourceLabel(source);
  if (/used-untruncated/i.test(status)) return true;
  if (/truncated|missing|not-covered|baseline-conflict|unused/i.test(status) && AUTOMATION_OR_USER_TOOL_RE.test(label) && !TRACE_TOOL_RE.test(String(source && source.capturedBy || ''))) return false;
  return TRACE_TOOL_RE.test(label);
}

function collectStringLengths(value, out = []) {
  if (typeof value === 'string') out.push(value.length);
  else if (Array.isArray(value)) for (const item of value) collectStringLengths(item, out);
  else if (value && typeof value === 'object') for (const item of Object.values(value)) collectStringLengths(item, out);
  return out;
}

function isChunkedValue(value) {
  return !!(
    value &&
    typeof value === 'object' &&
    CHUNK_ENCODING_RE.test(String(value.encoding || '')) &&
    Array.isArray(value.chunks)
  );
}

function hasOwn(obj, key) {
  return !!(obj && typeof obj === 'object' && Object.prototype.hasOwnProperty.call(obj, key));
}

function hasLengthAndHashOn(value, record, source) {
  if (isChunkedValue(value)) {
    return Number.isFinite(value.valueLength) && typeof value.sha256 === 'string' && /^[a-f0-9]{64}$/i.test(value.sha256);
  }
  if (value && typeof value === 'object') {
    const metrics = collectValueMetrics(value);
    if (metrics.chunked.length) {
      return metrics.chunked.every(info =>
        Number.isFinite(info.value.valueLength) &&
        typeof info.value.sha256 === 'string' &&
        /^[a-f0-9]{64}$/i.test(info.value.sha256)
      );
    }
  }
  return (
    (hasOwn(record, 'valueLength') || hasOwn(source, 'valueLength')) &&
    (hasOwn(record, 'sha256') || hasOwn(source, 'sha256'))
  );
}

function collectValueMetrics(value, out = { maxLen: 0, chunked: [], badMarkers: [] }, pathParts = []) {
  const label = pathParts.join('.') || 'result';
  if (typeof value === 'string') {
    out.maxLen = Math.max(out.maxLen, value.length);
    if (BAD_TRUNCATED_TEXT_RE.test(value)) out.badMarkers.push(`${label} 包含截断标记或可见片段标记`);
  } else if (Array.isArray(value)) {
    value.forEach((item, idx) => collectValueMetrics(item, out, pathParts.concat(String(idx))));
  } else if (value && typeof value === 'object') {
    if (isChunkedValue(value)) {
      const joined = value.chunks.join('');
      out.maxLen = Math.max(out.maxLen, Number(value.valueLength) || joined.length);
      out.chunked.push({ path: label, value, joinedLength: joined.length });
    }
    for (const [key, item] of Object.entries(value)) {
      if (BAD_TRUNCATED_KEY_RE.test(key)) out.badMarkers.push(`${label}.${key} 使用了 Trace 可见片段字段，不能作为最终值`);
      collectValueMetrics(item, out, pathParts.concat(key));
    }
  }
  return out;
}

function validateChunkedValue(itemPath, chunk) {
  const problems = [];
  const warnings = [];
  const encoding = String(chunk.encoding || '');
  const joined = Array.isArray(chunk.chunks) ? chunk.chunks.join('') : '';
  if (!CHUNK_ENCODING_RE.test(encoding)) problems.push(`样本 ${itemPath} 的分片 encoding 不合法：${encoding || '未指定'}。`);
  if (!Array.isArray(chunk.chunks) || chunk.chunks.some(v => typeof v !== 'string')) problems.push(`样本 ${itemPath} 的 chunks 必须是字符串数组。`);
  if (!Number.isFinite(chunk.valueLength)) problems.push(`样本 ${itemPath} 的分片结果缺少数值型 valueLength。`);
  if (!Number.isFinite(chunk.chunkSize) || chunk.chunkSize <= 0) problems.push(`样本 ${itemPath} 的分片结果缺少有效 chunkSize。`);
  if (chunk.truncated !== false) problems.push(`样本 ${itemPath} 的分片结果必须显式 truncated:false。`);
  if (Number.isFinite(chunk.valueLength) && joined.length !== chunk.valueLength) {
    problems.push(`样本 ${itemPath} 的 chunks 拼接长度 ${joined.length} 与 valueLength ${chunk.valueLength} 不一致。`);
  }
  if (Number.isFinite(chunk.chunkSize)) {
    const tooLarge = (chunk.chunks || []).find(v => v.length > chunk.chunkSize);
    if (tooLarge) warnings.push(`样本 ${itemPath} 存在超过 chunkSize 的分片；请确认分片写入逻辑没有异常。`);
  }
  if (typeof chunk.sha256 !== 'string' || !/^[a-f0-9]{64}$/i.test(chunk.sha256)) {
    problems.push(`样本 ${itemPath} 的长指纹分片缺少完整 sha256；必须先在真实浏览器采样 Hook 中 finalize，再写入 fixture。`);
  }
  if (BAD_TRUNCATED_TEXT_RE.test(joined)) problems.push(`样本 ${itemPath} 的分片拼接结果包含截断标记，不能作为最终值。`);
  return { problems, warnings };
}

function collectResultRecords(node, out = [], pathParts = []) {
  if (!node || typeof node !== 'object') return out;
  if (Object.prototype.hasOwnProperty.call(node, 'result')) {
    out.push({ path: pathParts.join('.') || '$', record: node, value: node.result });
  }
  for (const [key, value] of Object.entries(node)) {
    if (key === 'source' || key === 'valueSource' || key === 'match') continue;
    if (value && typeof value === 'object') collectResultRecords(value, out, pathParts.concat(key));
  }
  return out;
}

function validateValueSources(fp) {
  const problems = [];
  const warnings = [];
  const sourceSummary = {
    totalRecords: 0,
    inheritedSource: 0,
    explicitSource: 0,
    traceSource: 0,
    sampledSource: 0,
    longValueRecords: 0,
    chunkedLongValueRecords: 0,
    blockedTruncatedResultRecords: 0,
    badSourceRecords: 0
  };
  const rootSource = fp && fp.source;

  function validateSource(source, label, record, inherited) {
    if (!source || typeof source !== 'object') {
      problems.push(`${label} 缺少真实值来源 source / capturedBy；必须优先使用未截断 Trace，Trace 不可用时用已确认取证工具采样，不能由 AI 猜值。`);
      return;
    }
    const sourceText = jsonText(source);
    const labelText = sourceLabel(source);
    const isFixtureRoot = label === 'fixture.source';
    if (!hasSourceMeta(source)) problems.push(`${label} 的 source 缺少 mode / capturedBy / tool / sourceType 等来源字段。`);
    if (!REAL_VALUE_SOURCE_RE.test(sourceText)) problems.push(`${label} 的 source 未体现真实浏览器证据来源；请记录 RuyiTrace 未截断值，或 ruyiPage / Camoufox / CloakBrowser / 手动浏览器采样来源。`);
    if (BAD_VALUE_SOURCE_RE.test(sourceText)) {
      if (!isFixtureRoot) sourceSummary.badSourceRecords += 1;
      problems.push(`${label} 的 source 疑似为 AI 猜值、静态分析、默认值、随机值、mock 值或 Node.js 模拟库结果，不能作为最终指纹回放值。`);
    }
    const status = traceStatusOf(source, record);
    if (!status) warnings.push(`${label} 缺少 traceStatus；建议记录 used-untruncated / unused / missing / not-covered / truncated / baseline-conflict，明确是否优先检查 Trace。`);
    if (!isFixtureRoot && isTraceValueSource(source, record)) sourceSummary.traceSource += 1;
    if (!isFixtureRoot && AUTOMATION_OR_USER_TOOL_RE.test(labelText)) sourceSummary.sampledSource += 1;
  }

  validateSource(rootSource, 'fixture.source', null, false);
  const records = collectResultRecords(fp);
  sourceSummary.totalRecords = records.length;
  for (const item of records) {
    const source = item.record.source || item.record.valueSource || rootSource;
    const inherited = !(item.record.source || item.record.valueSource);
    if (inherited) sourceSummary.inheritedSource += 1;
    else sourceSummary.explicitSource += 1;
    validateSource(source, `样本 ${item.path}`, item.record, inherited);

    const metrics = collectValueMetrics(item.value);
    const maxLen = metrics.maxLen;
    if (maxLen >= LONG_VALUE_THRESHOLD) sourceSummary.longValueRecords += 1;
    if (metrics.chunked.length) sourceSummary.chunkedLongValueRecords += metrics.chunked.length;
    for (const marker of metrics.badMarkers) {
      sourceSummary.blockedTruncatedResultRecords += 1;
      problems.push(`样本 ${item.path} ${marker}；不能把 RuyiTrace 可见片段、clip 片段或未知真实长度写入最终 fixture。`);
    }
    for (const chunkInfo of metrics.chunked) {
      const chunkResult = validateChunkedValue(`${item.path}.${chunkInfo.path}`, chunkInfo.value);
      problems.push(...chunkResult.problems);
      warnings.push(...chunkResult.warnings);
    }
    const valueIsMarkedTruncated = item.record.truncated === true || (source && source.truncated === true);
    const status = traceStatusOf(source, item.record);
    if (valueIsMarkedTruncated) problems.push(`样本 ${item.path} 标记为 truncated=true，不能作为最终回放值；请用同一 baseline 下的取证工具补采完整值。`);
    if (isTraceValueSource(source, item.record) && (maxLen >= LONG_VALUE_THRESHOLD || isTruncatedTraceStatus(status) || valueIsMarkedTruncated)) {
      sourceSummary.blockedTruncatedResultRecords += 1;
      problems.push(`样本 ${item.path} 来自 Trace 且疑似长字段截断；不能把 RuyiTrace 4000 / 4096 可见片段作为完整指纹值，请用同一 baseline 下的 ruyiPage / Camoufox / CloakBrowser / 手动浏览器补采完整值。`);
    }
    if (maxLen >= LONG_VALUE_THRESHOLD && inherited) {
      problems.push(`样本 ${item.path} 是长字符串 / 大结果但未记录每条样本自己的 source、valueLength 和 sha256；请补充完整浏览器采样来源，避免误把 Trace 4000 / 4096 字符可见片段当成真实值。`);
    }
    if (maxLen >= LONG_VALUE_THRESHOLD && !hasLengthAndHashOn(item.value, item.record, source)) {
      problems.push(`样本 ${item.path} 长度达到 ${maxLen}，但缺少完整 valueLength 与 sha256；长指纹必须通过真实浏览器完整采样或分片保存并记录完整 hash。`);
    }
  }
  return { problems, warnings, sourceSummary };
}

function inspectFixture(file) {
  const problems = [];
  const warnings = [];
  const counts = {
    canvasToDataURL: 0,
    canvasToBlob: 0,
    canvasMeasureText: 0,
    canvasGetImageData: 0,
    webglGetParameter: 0,
    webglGetSupportedExtensions: 0,
    webglGetExtension: 0,
    webglGetShaderPrecisionFormat: 0,
    webglReadPixels: 0,
    webgpuRequestAdapter: 0,
    audioStartRendering: 0,
    audioGetChannelData: 0,
    domGetBoundingClientRect: 0,
    domOffset: 0,
  };
  let fixture = null;
  if (!file || !exists(file)) {
    problems.push(`未找到指纹 fixture：${file || '未指定'}`);
    return { fixture, counts, problems, warnings };
  }
  try { fixture = readJson(file); } catch (err) {
    problems.push(`指纹 fixture JSON 解析失败：${err.message}`);
    return { fixture, counts, problems, warnings };
  }
  const fp = fixture.fingerprint && typeof fixture.fingerprint === 'object' ? fixture.fingerprint : fixture;
  counts.canvasToDataURL = countArray(fp.canvas && fp.canvas.toDataURL);
  counts.canvasToBlob = countArray(fp.canvas && fp.canvas.toBlob);
  counts.canvasMeasureText = countArray(fp.canvas && fp.canvas.measureText);
  counts.canvasGetImageData = countArray(fp.canvas && fp.canvas.getImageData);
  counts.webglGetParameter = countArray(fp.webgl && fp.webgl.getParameter);
  counts.webglGetSupportedExtensions = hasResultObject(fp.webgl && fp.webgl.getSupportedExtensions) ? 1 : countArray(fp.webgl && fp.webgl.getSupportedExtensions);
  counts.webglGetExtension = countArray(fp.webgl && fp.webgl.getExtension);
  counts.webglGetShaderPrecisionFormat = countArray(fp.webgl && fp.webgl.getShaderPrecisionFormat);
  counts.webglReadPixels = countArray(fp.webgl && fp.webgl.readPixels);
  counts.webgpuRequestAdapter = countArray(fp.webgpu && fp.webgpu.requestAdapter);
  counts.audioStartRendering = countArray(fp.audio && fp.audio.startRendering);
  counts.audioGetChannelData = countArray(fp.audio && fp.audio.getChannelData);
  counts.domGetBoundingClientRect = countArray(fp.domGeometry && fp.domGeometry.getBoundingClientRect);
  counts.domOffset = countArray(fp.domGeometry && fp.domGeometry.offset);

  const baselineId = pickBaselineId(fp);
  if (!baselineId) problems.push('指纹 fixture 缺少 baselineId；必须先创建 case/notes/fingerprint-baseline.json，并让 fixture 绑定同一 baselineId。');
  if (!fp.source) problems.push('指纹 fixture 缺少 source 字段；必须记录真实值来源，优先使用未截断 Trace，Trace 不可用时使用已确认取证工具采样。');
  const sourceResult = validateValueSources(fp);
  problems.push(...sourceResult.problems);
  warnings.push(...sourceResult.warnings);
  return { fixture: fp, baselineId, counts, problems, warnings, sourceSummary: sourceResult.sourceSummary };
}

function inspectBaseline(caseDir, fixtureResult) {
  const problems = [];
  const warnings = [];
  const baselineFile = path.join(caseDir, 'notes', 'fingerprint-baseline.json');
  const result = { file: baselineFile, present: exists(baselineFile), baselineId: '', conflicts: [] };
  if (!result.present) {
    problems.push('缺少指纹基线文件 case/notes/fingerprint-baseline.json；涉及指纹采样时必须先固定同一 case 的 fingerprint baseline。');
    return { result, problems, warnings };
  }
  let baseline;
  try { baseline = readJson(baselineFile); } catch (err) {
    problems.push(`指纹基线 JSON 解析失败：${err.message}`);
    return { result, problems, warnings };
  }
  result.baselineId = String(baseline.baselineId || '');
  if (!result.baselineId) problems.push('fingerprint-baseline.json 缺少 baselineId。');
  if (fixtureResult.baselineId && result.baselineId && fixtureResult.baselineId !== result.baselineId) {
    problems.push(`指纹 fixture baselineId 与基线不一致：fixture=${fixtureResult.baselineId}，baseline=${result.baselineId}。不得混用不同随机指纹样本。`);
  }
  const fp = fixtureResult.fixture || {};
  const source = fp.source || {};
  const checks = [
    ['userAgent', source.userAgent, baseline.navigator && baseline.navigator.userAgent],
    ['timezone', source.timezone, baseline.network && baseline.network.timezone],
    ['locale', source.locale, baseline.network && baseline.network.locale],
  ];
  for (const [name, a, b] of checks) {
    if (a && b && String(a) !== String(b)) result.conflicts.push({ field: name, fixture: String(a), baseline: String(b) });
  }
  if (result.conflicts.length) {
    problems.push(`指纹 fixture 与 baseline 核心字段冲突：${result.conflicts.map(x => `${x.field}: fixture=${x.fixture}, baseline=${x.baseline}`).join('；')}。请重新采样或生成新 baseline。`);
  }
  return { result, problems, warnings };
}

const REQUIRE_RULES = {
  canvas: ['canvasToDataURL', 'canvasMeasureText', 'canvasGetImageData'],
  webgl: ['webglGetParameter', 'webglGetSupportedExtensions', 'webglGetShaderPrecisionFormat', 'webglReadPixels'],
  webgpu: ['webgpuRequestAdapter'],
  audio: ['audioStartRendering', 'audioGetChannelData'],
  'dom-geometry': ['domGetBoundingClientRect', 'domOffset'],
  dom: ['domGetBoundingClientRect', 'domOffset'],
  font: ['canvasMeasureText', 'domOffset'],
  fonts: ['canvasMeasureText', 'domOffset'],
};

const BAD_RENDER_PATTERNS = [
  { name: 'node-canvas/canvas', pattern: /\b(require|import)\s*\(?\s*['"](?:canvas|node-canvas)['"]|from\s+['"](?:canvas|node-canvas)['"]/i },
  { name: 'headless-gl/gl', pattern: /\b(require|import)\s*\(?\s*['"](?:gl|headless-gl)['"]|from\s+['"](?:gl|headless-gl)['"]/i },
  { name: '浏览器自动化', pattern: /\b(playwright|puppeteer|selenium|cloakbrowser|ruyipage|page\.goto|browser\.launch|chromium\.launch)\b/i },
];

function inspectEnvCode(files, root) {
  const problems = [];
  const warnings = [];
  const hits = [];
  for (const file of files) {
    if (!exists(file)) continue;
    const text = readText(file);
    for (const item of BAD_RENDER_PATTERNS) {
      if (item.pattern.test(text)) hits.push({ file: rel(root, file), type: item.name });
    }
    if (/toDataURL|getImageData|measureText|getParameter|getBoundingClientRect/.test(text) && !/fingerprint|回放|replay|fixture/i.test(text)) {
      warnings.push(`${rel(root, file)} 涉及指纹终端 API，但未明显体现 fixture / replay；请确认不是在 Node.js 中伪造渲染过程。`);
    }
  }
  if (hits.length) {
    problems.push(`发现不推荐的指纹实现方向：${hits.map(h => `${h.file}(${h.type})`).join('、')}。应使用真实浏览器采样值回放，不要在最终项目中依赖渲染库或自动化浏览器计算指纹。`);
  }
  return { problems, warnings, hits };
}

function defaultFixture(caseDir) {
  const candidates = [
    path.join(caseDir, 'fixtures', 'fingerprint.fixture.json'),
    path.join(caseDir, 'fixtures', 'sample.fixture.json'),
  ];
  return candidates.find(exists) || candidates[0];
}

function defaultEnvFiles(caseDir) {
  const result = path.join(caseDir, 'result');
  return walk(result).filter(p => ['.js', '.mjs', '.cjs'].includes(ext(p)));
}

function check(args) {
  const caseDir = args.caseDir ? path.resolve(args.caseDir) : (args.fixture ? path.resolve(path.dirname(args.fixture), '..') : process.cwd());
  const fixtureFile = args.fixture ? path.resolve(args.fixture) : defaultFixture(caseDir);
  const envFiles = args.envFile ? [path.resolve(args.envFile)] : defaultEnvFiles(caseDir);
  const required = String(args.require || '').split(',').map(s => s.trim().toLowerCase()).filter(Boolean);
  const problems = [];
  const warnings = [];

  const fixtureResult = inspectFixture(fixtureFile);
  problems.push(...fixtureResult.problems);
  warnings.push(...fixtureResult.warnings);

  for (const item of required) {
    const rules = REQUIRE_RULES[item] || [];
    if (!rules.length) warnings.push(`未知 require 类型：${item}`);
    const ok = rules.some(k => fixtureResult.counts[k] > 0);
    if (!ok) problems.push(`要求 ${item} 指纹样本，但 fixture 中未发现对应终端 API 返回值。`);
  }

  const baselineResult = inspectBaseline(caseDir, fixtureResult);
  problems.push(...baselineResult.problems);
  warnings.push(...baselineResult.warnings);

  const envResult = inspectEnvCode(envFiles, caseDir);
  problems.push(...envResult.problems);
  warnings.push(...envResult.warnings);

  return {
    caseDir,
    fixtureFile,
    envFiles: envFiles.map(p => rel(caseDir, p)),
    required,
    clean: problems.length === 0,
    baseline: baselineResult.result,
    fixtureBaselineId: fixtureResult.baselineId || '',
    counts: fixtureResult.counts,
    sourceSummary: fixtureResult.sourceSummary || {
      totalRecords: 0,
      inheritedSource: 0,
      explicitSource: 0,
      traceSource: 0,
      sampledSource: 0,
      longValueRecords: 0,
      chunkedLongValueRecords: 0,
      blockedTruncatedResultRecords: 0,
      badSourceRecords: 0
    },
    badImplementationHits: envResult.hits,
    problems,
    warnings,
  };
}

function renderMarkdown(result) {
  const lines = [
    '# 指纹 fixture 与回放实现检查',
    '',
    `case 目录：${result.caseDir}`,
    `fixture：${result.fixtureFile}`,
    `是否通过：${result.clean ? '是' : '否'}`,
    '',
    '## 指纹基线',
    `- baseline 文件：${result.baseline.file}`,
    `- baseline 是否存在：${result.baseline.present ? '是' : '否'}`,
    `- baselineId：${result.baseline.baselineId || '未发现'}`,
    `- fixture baselineId：${result.fixtureBaselineId || '未发现'}`,
    `- 核心字段冲突：${result.baseline.conflicts.length ? '是' : '否'}`,
    '',
    '## 样本覆盖统计',
  ];
  for (const [k, v] of Object.entries(result.counts)) lines.push(`- ${k}：${v}`);
  lines.push('', '## 指纹值来源检查');
  lines.push(`- result 样本数量：${result.sourceSummary.totalRecords}`);
  lines.push(`- 显式 source 样本：${result.sourceSummary.explicitSource}`);
  lines.push(`- 继承全局 source 样本：${result.sourceSummary.inheritedSource}`);
  lines.push(`- Trace 来源样本：${result.sourceSummary.traceSource}`);
  lines.push(`- 自动化 / 手动浏览器采样来源样本：${result.sourceSummary.sampledSource}`);
  lines.push(`- 长字段样本：${result.sourceSummary.longValueRecords}`);
  lines.push(`- 分片长字段样本：${result.sourceSummary.chunkedLongValueRecords}`);
  lines.push(`- 被阻断的截断 / 可见片段样本：${result.sourceSummary.blockedTruncatedResultRecords}`);
  lines.push(`- 疑似猜值 / 默认值 / 模拟库来源样本：${result.sourceSummary.badSourceRecords}`);
  lines.push('', '## 检查的 env 文件');
  if (result.envFiles.length) for (const f of result.envFiles) lines.push(`- ${f}`);
  else lines.push('- 未发现 result 下的 JS env 文件');
  if (result.problems.length) {
    lines.push('', '## 问题');
    for (const p of result.problems) lines.push(`- ${p}`);
  }
  if (result.warnings.length) {
    lines.push('', '## 提醒');
    for (const w of result.warnings) lines.push(`- ${w}`);
  }
  return lines.join('\n') + '\n';
}

try {
  const args = parseArgs(process.argv);
  if (args.help) { console.log(usage()); process.exit(0); }
  const result = check(args);
  if (args.json) console.log(JSON.stringify(result, null, 2));
  if (args.markdown) process.stdout.write(renderMarkdown(result));
  process.exit(result.clean ? 0 : 1);
} catch (err) {
  console.error(err.message || String(err));
  console.error(usage());
  process.exit(1);
}