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

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

function parseArgs(argv) {
  const args = {
    caseDir: '',
    traces: [],
    maxLines: 200000,
    json: false,
    markdown: false,
  };
  for (let i = 2; i < argv.length; i++) {
    const arg = argv[i];
    if (arg === '--case-dir' || arg === '--case' || arg === '-d') args.caseDir = argv[++i] || '';
    else if (arg === '--trace' || arg === '--input' || arg === '-i') args.traces.push(argv[++i] || '');
    else if (arg === '--max-lines') args.maxLines = Number(argv[++i] || args.maxLines);
    else if (arg === '--json') args.json = true;
    else if (arg === '--markdown') args.markdown = true;
    else if (arg === '--help' || arg === '-h') args.help = true;
    else throw new Error(`未知参数：${arg}`);
  }
  if (!args.json && !args.markdown) args.markdown = true;
  return args;
}

function usage() {
  return `用法：
  node scripts/analyze_trace_complexity.js --case-dir case --markdown
  node scripts/analyze_trace_complexity.js --trace case/ruyi-trace/logs/trace.ndjson --json
  node scripts/analyze_trace_complexity.js --trace case/tmp/env-trace.jsonl --markdown

说明：基于 RuyiTrace / Node trace 日志评估补环境复杂度、风险点和优先级。复杂度评估只用于理解项目，不自动决定是否使用 isolated-vm、vm 或 jsEnv。`;
}

function exists(p) {
  try {
    fs.accessSync(p);
    return true;
  } catch {
    return false;
  }
}

function stat(p) {
  try {
    return fs.statSync(p);
  } catch {
    return null;
  }
}

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 rel(root, p) {
  return (path.relative(root, p) || '.').replace(/\\/g, '/');
}

function uniq(arr) {
  return [...new Set(arr)].filter(Boolean).sort();
}

const CATEGORY_PATTERNS = [
  ['navigator', /\bnavigator\b|Navigator\.prototype|userAgent|webdriver|plugins|mimeTypes|hardwareConcurrency|deviceMemory/ig],
  ['document', /\bdocument\b|Document\.prototype|document\.cookie|querySelector|createElement|getElementById|documentElement|document\.all/ig],
  ['iframe-realm', /iframe|contentWindow|contentDocument|defaultView|srcdoc|document\.write|document\.close/ig],
  ['location', /\blocation\b|Location\.prototype|href|origin|hostname|pathname|search|hash/ig],
  ['screen', /\bscreen\b|Screen\.prototype|availWidth|availHeight|colorDepth|pixelDepth|orientation/ig],
  ['storage', /localStorage|sessionStorage|Storage\.prototype|getItem|setItem|removeItem/ig],
  ['cookie', /document\.cookie|Set-Cookie|\bcookie\b/ig],
  ['crypto', /\bcrypto\b|getRandomValues|randomUUID|SubtleCrypto|crypto\.subtle/ig],
  ['performance-time', /performance|performance\.now|timeOrigin|Date\.now|new Date|setTimeout|requestAnimationFrame/ig],
  ['canvas', /HTMLCanvasElement|CanvasRenderingContext2D|toDataURL|toBlob|getImageData|measureText|canvas/ig],
  ['webgl', /WebGLRenderingContext|WebGL2RenderingContext|getParameter|readPixels|getSupportedExtensions|getShaderPrecisionFormat|webgl/ig],
  ['webgpu', /navigator\.gpu|GPUAdapter|requestAdapter|webgpu/ig],
  ['audio', /AudioContext|OfflineAudioContext|AnalyserNode|startRendering|getChannelData/ig],
  ['dom-geometry', /getBoundingClientRect|DOMRect|offsetWidth|offsetHeight|clientWidth|clientHeight|getClientRects/ig],
  ['dom-cssom', /DOMParser|innerHTML|HTMLUnknownElement|HTMLTextAreaElement|HTMLOptionElement|HTMLSelectElement|HTMLCollection|ShadowRoot|CSSStyleSheet|CSSStyleRule|CSSRuleList|getComputedStyle/ig],
  ['worker', /\bWorker\b|importScripts|postMessage|MessageChannel|MessagePort|BroadcastChannel/ig],
  ['wasm', /WebAssembly|instantiateStreaming|compileStreaming|\.wasm/ig],
  ['network', /\bfetch\b|XMLHttpRequest|Request\.prototype|Response\.prototype|Headers\.prototype|sendBeacon/ig],
  ['xhr-fetch-session-bridge', /live-session-bridge|offline-fixture|XMLHttpRequest|fetch|sendBeacon|curl_cffi|curl-cffi|CycleTLS|impers/ig],
  ['object-shape', /Object\.keys|Object\.getOwnPropertyNames|Object\.getOwnPropertyDescriptor|Object\.getOwnPropertySymbols|Reflect\.ownKeys|hasOwnProperty|propertyIsEnumerable|brand check|prototype walk/ig],
  ['private-state-leakage', /__readyState|__headers|__children|__parentNode|__responseHeaders|Object\.defineProperty\s*\([^)]*['"]_{1,2}[A-Za-z]|\bthis\s*\.\s*_{1,2}[A-Za-z]/ig],
  ['indexedDB', /indexedDB|IDBFactory|IDBRequest|IDBOpenDBRequest|IDBKeyRange|IDBDatabase/ig],
  ['history', /\bhistory\b|pushState|replaceState|popstate|referrer/ig],
  ['event-clone-error', /EventTarget|structuredClone|DataCloneError|ownKeys|ownNames|Reflect\.ownKeys|getOwnPropertyNames/ig],
  ['clock-timer', /Date\.now|performance\.now|setTimeout|clearTimeout|queueMicrotask|requestAnimationFrame/ig],
  ['writer-branch', /reload writer|form writer|final writer|HTMLFormElement\.submit|Location\.reload|cf-chl-gen|cf-chl-out|generatedForm/ig],
  ['performance-timeline', /PerformanceObserver|PerformanceResourceTiming|PerformanceEntry|PerformanceObserverEntryList|getEntries|PerformancePaintTiming|performance\.mark/ig],
];

const REALISM_PATTERNS = [
  ['Function.prototype.toString', /Function\.prototype\.toString|\.toString\s*\(\)/ig],
  ['Object.prototype.toString', /Object\.prototype\.toString|\[object\s+[A-Za-z]+]/ig],
  ['descriptor', /Object\.getOwnPropertyDescriptor|Object\.getOwnPropertyDescriptors|defineProperty|getOwnPropertyDescriptor/ig],
  ['prototype', /Object\.getPrototypeOf|setPrototypeOf|__proto__|prototype/ig],
  ['ownKeys', /Reflect\.ownKeys|Object\.keys|getOwnPropertyNames|getOwnPropertySymbols/ig],
  ['instanceof', /\binstanceof\b/ig],
  ['constructor.name', /constructor\.name|\.constructor\b/ig],
  ['Symbol.toStringTag', /Symbol\.toStringTag|@@toStringTag/ig],
];

const ASYNC_PATTERNS = [
  ['Promise', /\bPromise\b|queueMicrotask|then\(/ig],
  ['timer', /setTimeout|setInterval|requestAnimationFrame|cancelAnimationFrame/ig],
  ['message', /postMessage|MessageChannel|BroadcastChannel|message event/ig],
  ['observer', /MutationObserver|IntersectionObserver|ResizeObserver|PerformanceObserver/ig],
  ['xhr-fetch', /\bfetch\b|XMLHttpRequest|readystatechange|loadend/ig],
  ['indexedDB-async', /IDBRequest|onsuccess|onerror|transaction|openCursor/ig],
];

function countMatches(text, pattern) {
  pattern.lastIndex = 0;
  let count = 0;
  while (pattern.exec(text)) count += 1;
  return count;
}

function emptySignalMap(items) {
  return Object.fromEntries(items.map(([name]) => [name, 0]));
}

function discoverTraceFiles(args) {
  const files = [];
  for (const item of args.traces) {
    const resolved = path.resolve(item);
    if (exists(resolved)) files.push(resolved);
  }
  if (args.caseDir) {
    const caseDir = path.resolve(args.caseDir);
    const candidates = [
      path.join(caseDir, 'ruyi-trace', 'logs'),
      path.join(caseDir, 'tmp'),
      path.join(caseDir, 'notes'),
    ];
    for (const candidate of candidates) {
      for (const file of walk(candidate)) {
        if (/\.(ndjson|jsonl|json)$/i.test(file) && /trace|missing-env|ruyi|env/i.test(path.basename(file))) {
          files.push(file);
        }
      }
    }
  }
  return uniq(files);
}

function inspectLine(text, summary) {
  for (const [name, pattern] of CATEGORY_PATTERNS) {
    summary.categories[name] += countMatches(text, pattern);
  }
  for (const [name, pattern] of REALISM_PATTERNS) {
    summary.realism[name] += countMatches(text, pattern);
  }
  for (const [name, pattern] of ASYNC_PATTERNS) {
    summary.async[name] += countMatches(text, pattern);
  }

  const stackMatches = text.match(/(?:stack\.file|filename|file|url)["']?\s*[:=]\s*["']?([^"',\s)]+)/ig);
  if (stackMatches) {
    for (const raw of stackMatches.slice(0, 20)) summary.stackSignals.add(raw.slice(0, 160));
  }
}

function analyzeFile(file, args) {
  const result = {
    file,
    lines: 0,
    bytes: 0,
    truncatedByMaxLines: false,
    parseErrors: 0,
  };
  const text = fs.readFileSync(file, 'utf8').replace(/^\uFEFF/, '');
  result.bytes = Buffer.byteLength(text);
  const lines = text.split(/\r?\n/);
  for (const line of lines) {
    if (!line.trim()) continue;
    if (result.lines >= args.maxLines) {
      result.truncatedByMaxLines = true;
      break;
    }
    result.lines += 1;
  }
  return { result, lines: lines.slice(0, args.maxLines) };
}

function scoreSummary(summary) {
  const hitCategories = Object.entries(summary.categories).filter(([, count]) => count > 0).map(([name]) => name);
  const hitRealism = Object.entries(summary.realism).filter(([, count]) => count > 0).map(([name]) => name);
  const hitAsync = Object.entries(summary.async).filter(([, count]) => count > 0).map(([name]) => name);
  const fingerprintHits = ['canvas', 'webgl', 'webgpu', 'audio', 'dom-geometry', 'dom-cssom'].filter(name => summary.categories[name] > 0);
  const stateHits = ['storage', 'cookie', 'indexedDB', 'history', 'performance-time', 'performance-timeline', 'crypto', 'clock-timer'].filter(name => summary.categories[name] > 0);
  const envMatrixHitMap = [
    ['iframe-realm', 'iframe-realm'],
    ['worker', 'worker-task'],
    ['performance-timeline', 'performance-timeline'],
    ['dom-cssom', 'dom-cssom'],
    ['event-clone-error', 'event-clone-error'],
    ['xhr-fetch-session-bridge', 'xhr-fetch-session-bridge'],
    ['object-shape', 'object-shape'],
    ['private-state-leakage', 'private-state-leakage'],
    ['clock-timer', 'clock-timer'],
    ['writer-branch', 'writer-branch'],
  ];
  const envMatrixHits = envMatrixHitMap
    .filter(([source]) => summary.categories[source] > 0)
    .map(([, id]) => id);

  let score = 0;
  score += hitCategories.length * 2;
  score += hitRealism.length * 3;
  score += fingerprintHits.length * 4;
  score += hitAsync.length * 2;
  score += stateHits.length * 2;
  score += envMatrixHits.length * 3;
  if (summary.stackSignals.size >= 10) score += 6;
  else if (summary.stackSignals.size >= 3) score += 3;

  let level = '未知';
  if (summary.files.length === 0 || summary.totalLines === 0) level = '未知';
  else if (score >= 45 || fingerprintHits.length >= 3 || hitRealism.length >= 5) level = '高';
  else if (score >= 18 || fingerprintHits.length >= 1 || hitRealism.length >= 2) level = '中';
  else level = '低';

  return {
    score,
    level,
    hitCategories,
    hitRealism,
    hitAsync,
    fingerprintHits,
    stateHits,
    envMatrixHits,
    stackSignalCount: summary.stackSignals.size,
  };
}

function analyze(args) {
  const files = discoverTraceFiles(args);
  const root = args.caseDir ? path.resolve(args.caseDir) : process.cwd();
  const summary = {
    files: files.map(file => rel(root, file)),
    totalLines: 0,
    totalBytes: 0,
    categories: emptySignalMap(CATEGORY_PATTERNS),
    realism: emptySignalMap(REALISM_PATTERNS),
    async: emptySignalMap(ASYNC_PATTERNS),
    fileSummaries: [],
    stackSignals: new Set(),
    parseErrors: 0,
  };

  for (const file of files) {
    const { result, lines } = analyzeFile(file, args);
    summary.fileSummaries.push({
      ...result,
      file: rel(root, file),
    });
    summary.totalLines += result.lines;
    summary.totalBytes += result.bytes;
    for (const line of lines) {
      if (!line.trim()) continue;
      inspectLine(line, summary);
    }
  }

  const score = scoreSummary(summary);
  return {
    passed: true,
    complexity: score.level,
    score: score.score,
    source: {
      files: summary.files,
      totalLines: summary.totalLines,
      totalBytes: summary.totalBytes,
      fileSummaries: summary.fileSummaries,
    },
    signals: {
      categories: summary.categories,
      realism: summary.realism,
      async: summary.async,
      hitCategories: score.hitCategories,
      hitRealism: score.hitRealism,
      hitAsync: score.hitAsync,
      fingerprintHits: score.fingerprintHits,
      stateHits: score.stateHits,
      envMatrixHits: score.envMatrixHits,
      stackSignalCount: score.stackSignalCount,
    },
    conclusion: {
      frameworkBinding: false,
      note: 'Trace 复杂度评估只用于补环境范围、风险点和优先级，不自动决定是否使用 isolated-vm、vm 或 jsEnv。',
    },
  };
}

function renderMarkdown(result) {
  const lines = [];
  lines.push('# Trace 复杂度评估报告');
  lines.push('');
  lines.push(`- 复杂度等级：${result.complexity}`);
  lines.push(`- 分数：${result.score}`);
  lines.push(`- Trace 文件数：${result.source.files.length}`);
  lines.push(`- Trace 总行数：${result.source.totalLines}`);
  lines.push('- 与补环境框架关系：复杂度评估不决定框架选择，是否使用 isolated-vm / vm / jsEnv 仍以用户确认为准。');
  lines.push('');

  if (!result.source.files.length) {
    lines.push('未发现可用 Trace 日志，无法基于日志评估复杂度。');
    lines.push('');
    return lines.join('\n');
  }

  lines.push('## 命中的 WebAPI 类别');
  lines.push('');
  lines.push(result.signals.hitCategories.length ? result.signals.hitCategories.map(x => `- ${x}：${result.signals.categories[x]}`).join('\n') : '- 无明显命中');
  lines.push('');

  lines.push('## 真实性检测信号');
  lines.push('');
  lines.push(result.signals.hitRealism.length ? result.signals.hitRealism.map(x => `- ${x}：${result.signals.realism[x]}`).join('\n') : '- 无明显命中');
  lines.push('');

  lines.push('## 指纹、异步和状态风险');
  lines.push('');
  lines.push(`- 指纹 API：${result.signals.fingerprintHits.join('、') || '无明显命中'}`);
  lines.push(`- 异步链路：${result.signals.hitAsync.join('、') || '无明显命中'}`);
  lines.push(`- 状态依赖：${result.signals.stateHits.join('、') || '无明显命中'}`);
  lines.push(`- WebAPI 环境检测矩阵触发类：${result.signals.envMatrixHits.join('、') || '无明显命中'}`);
  lines.push(`- 调用栈分散信号数：${result.signals.stackSignalCount}`);
  lines.push('');

  lines.push('## 文件摘要');
  lines.push('');
  lines.push('| 文件 | 行数 | 字节数 | 达到最大行限制 |');
  lines.push('|---|---:|---:|---|');
  for (const item of result.source.fileSummaries) {
    lines.push(`| ${item.file} | ${item.lines} | ${item.bytes} | ${item.truncatedByMaxLines ? '是' : '否'} |`);
  }
  lines.push('');

  lines.push('## 使用说明');
  lines.push('');
  lines.push('- 该报告用于补环境范围、优先级和阶段报告。');
  lines.push('- 不要把复杂度等级写成自动选择补环境框架的依据。');
  lines.push('- 补环境框架选择仍然必须由用户确认；用户未选择时默认不使用框架。');
  return lines.join('\n');
}

function main() {
  const args = parseArgs(process.argv);
  if (args.help) {
    console.log(usage());
    return;
  }
  const result = analyze(args);
  if (args.json) console.log(JSON.stringify(result, null, 2));
  else console.log(renderMarkdown(result));
}

try {
  main();
} catch (error) {
  console.error(error && error.message ? error.message : String(error));
  process.exitCode = 2;
}