#!/usr/bin/env node
/**
 * PostToolUse Hook: 构建结果追踪器 (Phase 3)
 * Matcher: Bash
 *
 * 触发: 匹配构建/测试命令
 * 功能: 将构建结果记录到 debug/outcome-YYYY-MM-DD.jsonl
 *
 * 日志格式: { ts, command, outcome, errorHint, sessionId, skill, traceId }
 * Phase 2: errorHint 提取 + 成功率聚合 (outcome-aggregation.json)
 * Phase 3: 技能-结果关联 + 跨 hook 会话追踪
 *
 * stdin: { tool_name: "Bash", tool_input: { command }, tool_result: { stdout, stderr, exitCode } }
 * 退出码: 0 (始终放行，PostToolUse 不阻断)
 *
 * Fail-open: 任何异常 → exit(0)
 */

const fs = require('fs');
const path = require('path');
const { safeAppendJsonl } = require('./lib/safe-append.js');

const readStdin = require('./lib/read-stdin.js');

// ─── 路径解析 ────────────────────────────────────────
let debugDir;
try {
  const { PATHS } = require('../scripts/paths.config.js');
  debugDir = PATHS.debugDir;
} catch {
  debugDir = path.resolve(__dirname, '..', 'debug');
}

// ─── Feature Flag 检查 ───────────────────────────────
try {
  const { isEnabled } = require('../scripts/feature-flags.js');
  if (!isEnabled('build-outcome-tracker')) {
    process.exit(0);
  }
} catch {
  // feature-flags 加载失败 → 视为关闭，放行
  process.exit(0);
}

// ─── User Override 检查 ──────────────────────────────
try {
  const { isChecksDisabled } = require('../scripts/user-overrides.js');
  if (isChecksDisabled()) {
    process.exit(0);
  }
} catch {}

// ─── 构建/测试命令模式 ──────────────────────────────
const BUILD_TEST_PATTERNS = [
  /\bnpm\s+run\s+(build|test)\b/,
  /\bnpm\s+test\b/,
  /\bnpx\s+.*(?:build|test)\b/,
  /\byarn\s+(?:build|test)\b/,
  /\bpnpm\s+(?:run\s+)?(?:build|test)\b/,
  /\btsc\b/,
  /\bmake\b/,
  /\bcargo\s+(?:build|test)\b/,
  /\bgo\s+(?:build|test)\b/,
  /\bgcc\b/,
  /\bg\+\+\b/,
  /\bjavac\b/,
  /\bjest\b/,
  /\bvitest\b/,
  /\bmocha\b/,
  /\bpytest\b/,
  /\bdotnet\s+(?:build|test)\b/,
  /\bgradlew?\s+(?:build|test)\b/,
  /\bmvn\s+(?:compile|test|package|install)\b/,
  /\bwebpack\b/,
  /\bvite\s+build\b/,
  /\besbuild\b/,
];

function isBuildOrTestCommand(command) {
  if (!command || typeof command !== 'string') return false;
  return BUILD_TEST_PATTERNS.some(p => p.test(command));
}

// ─── T02: 管道命令检测 + 已知测试命令回退 ──────────────
const KNOWN_TEST_RUNNERS = [
  /\bvitest\b/, /\bjest\b/, /\bpytest\b/, /\bmocha\b/,
  /\bcargo\s+test\b/, /\bgo\s+test\b/, /\bdotnet\s+test\b/,
];

/**
 * 检测管道命令并提取基础命令
 * @param {string} command
 * @returns {{ isPipe: boolean, baseCommand: string, isKnownTestRunner: boolean }}
 */
function detectPipeline(command) {
  if (!command) return { isPipe: false, baseCommand: command, isKnownTestRunner: false };
  const isPipe = /\|/.test(command);
  const baseCommand = isPipe ? command.split('|')[0].trim() : command;
  const isKnownTestRunner = KNOWN_TEST_RUNNERS.some(p => p.test(baseCommand));
  return { isPipe, baseCommand, isKnownTestRunner };
}

// ─── Outcome 推断 ────────────────────────────────────
const FAILURE_PATTERNS = [
  /\berror\b/i,
  /\bfailed\b/i,
  /\bfailure\b/i,
  /\bERROR\b/,
  /\bFAILED\b/,
  /\bfatal\b/i,
  /\bexception\b/i,
  /\bsegfault\b/i,
  /exit\s+code\s+[1-9]/i,
  /\bnot\s+found\b/i,
  /\bcommand\s+failed\b/i,
];

const SUCCESS_PATTERNS = [
  /\bsuccess\b/i,
  /\bpassed\b/i,
  /\bcompleted?\b/i,
  /\bbuilt?\s+successfully\b/i,
  /\bdone\b/i,
  /\ball\s+tests?\s+passed\b/i,
  /\b0\s+errors?\b/i,
];

// ─── P1: 测试框架汇总行检测 (优先于 exitCode，不受管道影响) ──
const FRAMEWORK_RESULT_PATTERNS = [
  // vitest/jest: "X failed |" 或 "Tests  X passed"
  { pattern: /([1-9]\d*)\s+failed\s*[|\s]/i, success: false },
  { pattern: /Tests?\s+(\d+)\s+passed/i, success: true },
  // pytest: "X passed, Y failed" 或 "X passed in"
  { pattern: /(\d+)\s+passed,\s*(\d+)\s+failed/i, successFn: (m) => parseInt(m[2]) === 0 },
  { pattern: /(\d+)\s+passed(?:\s+in\s+[\d.]+s)?$/m, success: true },
  // cargo test
  { pattern: /test result:\s*ok/i, success: true },
  { pattern: /test result:\s*FAILED/i, success: false },
  // go test
  { pattern: /^PASS$/m, success: true },
  { pattern: /^FAIL\b/m, success: false },
  // tsc/build
  { pattern: /compiled?\s+successfully/i, success: true },
  { pattern: /build\s+succeeded/i, success: true },
  { pattern: /build\s+failed/i, success: false },
];

/**
 * 从输出尾部检测测试框架汇总行
 * @param {string} text - 合并后的输出文本
 * @returns {'success'|'failure'|null}
 */
function detectFrameworkResult(text) {
  if (!text) return null;
  const lastLines = text.split('\n').slice(-30).join('\n');
  for (const { pattern, success, successFn } of FRAMEWORK_RESULT_PATTERNS) {
    const match = lastLines.match(pattern);
    if (match) {
      return (successFn ? successFn(match) : success) ? 'success' : 'failure';
    }
  }
  return null;
}

function inferOutcome(toolResult) {
  if (!toolResult) return 'unknown';

  // 组合输出文本
  const text = [toolResult.stdout || '', toolResult.stderr || '', toolResult.content || ''].join('\n');

  // P1: 优先检测测试框架汇总行 (不受管道 exitCode 影响)
  const frameworkResult = detectFrameworkResult(text);
  if (frameworkResult) return frameworkResult;

  // exitCode: 字符串形式也接受
  const exitCode = typeof toolResult.exitCode === 'number' ? toolResult.exitCode
    : typeof toolResult.exitCode === 'string' ? parseInt(toolResult.exitCode, 10)
    : null;

  // 非零退出码 → 可靠的失败信号
  if (exitCode !== null && !isNaN(exitCode) && exitCode !== 0) return 'failure';

  // 通用模式匹配
  const hasFailure = FAILURE_PATTERNS.some(p => p.test(text));
  const hasSuccess = SUCCESS_PATTERNS.some(p => p.test(text));

  if (hasFailure && !hasSuccess) return 'failure';
  if (hasSuccess && !hasFailure) return 'success';
  if (hasFailure && hasSuccess) return 'failure'; // 有错误优先视为失败

  // exitCode 0 + 无内容信号 → 成功
  if (exitCode === 0) return 'success';

  return 'unknown';
}

// ─── Phase 2: errorHint 提取 ─────────────────────────
/**
 * 从 tool_result 中提取第一行含 error/fail/fatal 的文本作为 errorHint
 * @param {Object} toolResult
 * @returns {string} errorHint (≤150 chars) 或空字符串
 */
function extractErrorHint(toolResult) {
  if (!toolResult) return '';
  const text = [toolResult.stderr || '', toolResult.stdout || '', toolResult.content || ''].join('\n');
  const lines = text.split('\n');
  for (const line of lines) {
    if (/\b(?:error|fail|fatal)\b/i.test(line) && line.trim().length > 0) {
      return line.trim().slice(0, 150);
    }
  }
  return '';
}

// ─── Phase 2: 成功率聚合 ─────────────────────────────
const AGGREGATION_FILE_PATH = path.join(debugDir, 'outcome-aggregation.json');
const MAX_AGGREGATION_COMMANDS = 50;

/**
 * 更新成功率聚合数据
 * @param {string} command - 构建命令
 * @param {string} outcome - success|failure|unknown
 */
/**
 * P2-FIX: 命令规范化 — 去除 tail/head 参数差异和路径格式差异
 * 减少 near-duplicate key (如 tail -5 vs tail -15)
 */
function normalizeCommand(cmd) {
  return (cmd || '')
    .replace(/\|\s*(tail|head)\s+-\d+/g, '')  // 去除 tail -N / head -N
    .replace(/\\+/g, '/')                        // 统一路径分隔符
    .replace(/\/\//g, '/')                        // 去除双斜杠
    .trim()
    .slice(0, 150);                                 // 截断到 150 字符
}

function updateAggregation(command, outcome) {
  // H9: O_EXCL 文件锁保护 read-modify-write 操作
  const lockFile = AGGREGATION_FILE_PATH + '.lock';
  let lockFd;
  try { lockFd = fs.openSync(lockFile, 'wx'); } catch { return; }
  try {
    let agg = {};
    if (fs.existsSync(AGGREGATION_FILE_PATH)) {
      agg = JSON.parse(fs.readFileSync(AGGREGATION_FILE_PATH, 'utf8'));
    }

    const cmdKey = normalizeCommand(command);
    if (!agg[cmdKey]) {
      agg[cmdKey] = { total: 0, success: 0, failure: 0, unknown: 0, lastUpdated: '' };
    }

    agg[cmdKey].total++;
    if (outcome === 'success') agg[cmdKey].success++;
    else if (outcome === 'failure') agg[cmdKey].failure++;
    else agg[cmdKey].unknown++;
    agg[cmdKey].lastUpdated = new Date().toISOString();

    // LRU 淘汰: 超过上限时移除最旧条目
    const keys = Object.keys(agg);
    if (keys.length > MAX_AGGREGATION_COMMANDS) {
      const sorted = keys.sort((a, b) => {
        const ta = agg[a].lastUpdated || '';
        const tb = agg[b].lastUpdated || '';
        return ta.localeCompare(tb);
      });
      // 删除最旧的条目直到达到上限
      const toRemove = sorted.slice(0, keys.length - MAX_AGGREGATION_COMMANDS);
      for (const k of toRemove) {
        delete agg[k];
      }
    }

    if (!fs.existsSync(debugDir)) fs.mkdirSync(debugDir, { recursive: true });
    // P2: temp+rename 原子写入，防止并发半写
    const _aggTmp = AGGREGATION_FILE_PATH + '.tmp.' + process.pid;
    fs.writeFileSync(_aggTmp, JSON.stringify(agg, null, 2) + '\n');
    fs.renameSync(_aggTmp, AGGREGATION_FILE_PATH);
  } catch {}
  // H9: 释放锁
  try { fs.closeSync(lockFd); fs.unlinkSync(lockFile); } catch {}
}

// ─── Phase 1: 技能归因 ───────────────────────────────
function getRouteSkill() {
  try {
    const routeStateFile = path.join(debugDir, 'route-state-current.json');
    if (fs.existsSync(routeStateFile)) {
      const state = JSON.parse(fs.readFileSync(routeStateFile, 'utf8'));
      return (state.routing && state.routing.primary) || state.skill || 'unknown';
    }
  } catch {}
  return 'unknown';
}

function generateTraceId() {
  const ts = Date.now().toString(36);
  const rand = Math.random().toString(36).slice(2, 8);
  return `${ts}-${rand}`;
}

// ─── Phase 3: 技能-结果关联 (D3) ─────────────────────
const SKILL_CORRELATION_FILE = path.join(debugDir, 'skill-outcome-correlation.json');
const MAX_SKILLS = 30;
const RECENT_WINDOW_SIZE = 20;

/**
 * 计算趋势: 前半 vs 后半成功率
 * @param {Array<string>} recentWindow - 最近的 outcome 列表
 * @returns {'improving'|'worsening'|'stable'|'insufficient'}
 */
function computeTrend(recentWindow) {
  if (!recentWindow || recentWindow.length < 6) return 'insufficient';
  const mid = Math.floor(recentWindow.length / 2);
  const firstHalf = recentWindow.slice(0, mid);
  const secondHalf = recentWindow.slice(mid);

  const rate = (arr) => arr.filter(o => o === 'success').length / arr.length;
  const firstRate = rate(firstHalf);
  const secondRate = rate(secondHalf);

  const diff = secondRate - firstRate;
  if (diff > 0.15) return 'improving';
  if (diff < -0.15) return 'worsening';
  return 'stable';
}

/**
 * 更新技能-结果关联数据
 * @param {string} skill - 技能名称
 * @param {string} outcome - success|failure|unknown
 */
function updateSkillCorrelation(skill, outcome) {
  try {
    if (!skill || skill === 'unknown') return;
    if (!fs.existsSync(debugDir)) fs.mkdirSync(debugDir, { recursive: true });

    let data = { skills: {}, generatedAt: '' };
    try {
      if (fs.existsSync(SKILL_CORRELATION_FILE)) {
        data = JSON.parse(fs.readFileSync(SKILL_CORRELATION_FILE, 'utf8'));
      }
    } catch {}

    if (!data.skills) data.skills = {};
    if (!data.skills[skill]) {
      data.skills[skill] = { total: 0, success: 0, failure: 0, unknown: 0, successRate: 0, lastUpdated: '', recentWindow: [] };
    }

    const entry = data.skills[skill];
    entry.total++;
    if (outcome === 'success') entry.success++;
    else if (outcome === 'failure') entry.failure++;
    else entry.unknown++;
    entry.successRate = entry.total > 0 ? Math.round((entry.success / entry.total) * 1000) / 1000 : 0;
    entry.lastUpdated = new Date().toISOString();

    // recentWindow: 保留最近 RECENT_WINDOW_SIZE 条
    if (!entry.recentWindow) entry.recentWindow = [];
    entry.recentWindow.push(outcome);
    if (entry.recentWindow.length > RECENT_WINDOW_SIZE) {
      entry.recentWindow = entry.recentWindow.slice(-RECENT_WINDOW_SIZE);
    }

    // LRU 淘汰: 超过 MAX_SKILLS 时移除最旧
    const skillKeys = Object.keys(data.skills);
    if (skillKeys.length > MAX_SKILLS) {
      const sorted = skillKeys.sort((a, b) => {
        const ta = data.skills[a].lastUpdated || '';
        const tb = data.skills[b].lastUpdated || '';
        return ta.localeCompare(tb);
      });
      const toRemove = sorted.slice(0, skillKeys.length - MAX_SKILLS);
      for (const k of toRemove) delete data.skills[k];
    }

    data.generatedAt = new Date().toISOString();
    // P2: temp+rename 原子写入，防止并发半写
    const _corrTmp = SKILL_CORRELATION_FILE + '.tmp.' + process.pid;
    fs.writeFileSync(_corrTmp, JSON.stringify(data, null, 2) + '\n');
    fs.renameSync(_corrTmp, SKILL_CORRELATION_FILE);
  } catch {}
}

/**
 * 获取技能的成功率和趋势 (导出供外部消费)
 * @param {string} skill - 技能名称
 * @returns {{ successRate: number, total: number, trend: string }|null}
 */
function getSkillSuccessRate(skill) {
  try {
    if (!fs.existsSync(SKILL_CORRELATION_FILE)) return null;
    const data = JSON.parse(fs.readFileSync(SKILL_CORRELATION_FILE, 'utf8'));
    const entry = data.skills && data.skills[skill];
    if (!entry || entry.total < 3) return null;
    return {
      successRate: entry.successRate,
      total: entry.total,
      trend: computeTrend(entry.recentWindow),
    };
  } catch {
    return null;
  }
}

// ─── 日志写入 ────────────────────────────────────────
function logOutcome(entry) {
  try {
    const dateStr = new Date().toISOString().slice(0, 10);
    const logFile = path.join(debugDir, `outcome-${dateStr}.jsonl`);
    safeAppendJsonl(logFile, entry);
  } catch {}
}

// ─── 主流程 ──────────────────────────────────────────
function main() {
  readStdin({ maxSize: 512 * 1024 }).then(input => {
    const command = input.tool_input?.command;

    // 非构建/测试命令 → 跳过
    if (!isBuildOrTestCommand(command)) {
      process.exit(0);
      return;
    }

    // 推断结果
    let outcome = inferOutcome(input.tool_result);

    // T02: 管道命令二次判定 — 已知测试命令 + unknown → 内容无失败关键词则视为 success
    if (outcome === 'unknown') {
      const pipe = detectPipeline(command);
      if (pipe.isKnownTestRunner) {
        const text = [
          (input.tool_result?.stdout || ''),
          (input.tool_result?.stderr || ''),
          (input.tool_result?.content || '')
        ].join('\n');
        const hasFail = /\bfail|\berror|\bFAIL|\bERROR/i.test(text);
        if (!hasFail) {
          outcome = 'success';
        }
      }
    }

    // Phase 2: errorHint 提取（仅失败时）
    const errorHint = outcome === 'failure' ? extractErrorHint(input.tool_result) : '';

    // Phase 1: 技能归因
    const skill = getRouteSkill();

    // Phase 3: 使用共享 traceId (D5)
    let traceId;
    try {
      const { getSessionTrace } = require('../scripts/session-trace.js');
      traceId = getSessionTrace().traceId;
    } catch {
      traceId = generateTraceId();
    }

    // 记录（Phase 2: 增加 errorHint 字段）
    const cmdNormalized = (command || '').slice(0, 200);
    // T02: 管道检测
    const pipeline = detectPipeline(command);

    logOutcome({
      ts: new Date().toISOString(),
      command: cmdNormalized,
      outcome,
      pipelineMode: pipeline.isPipe,
      errorHint,
      sessionId: input.session_id || 'unknown',
      skill,
      traceId,
    });

    // Phase 2: 更新聚合数据
    updateAggregation(cmdNormalized, outcome);

    // Phase 3: 技能-结果关联 (D3)
    try { updateSkillCorrelation(skill, outcome); } catch {}

    // Phase 3: 跨 hook 会话追踪 (D5)
    try {
      const { appendTraceEvent } = require('../scripts/session-trace.js');
      appendTraceEvent('build-outcome-tracker', 'outcome', {
        command: cmdNormalized,
        outcome,
        skill,
        errorHint: errorHint ? errorHint.slice(0, 80) : '',
      });
    } catch {}

    process.exit(0);
  }).catch(() => process.exit(0));
}

// 模块导出 (供测试)
if (typeof module !== 'undefined') {
  module.exports = { isBuildOrTestCommand, inferOutcome, detectFrameworkResult, detectPipeline, extractErrorHint, updateAggregation, getRouteSkill, generateTraceId, AGGREGATION_FILE_PATH, updateSkillCorrelation, getSkillSuccessRate, computeTrend };
}

if (require.main === module) {
  main();
}