#!/usr/bin/env node

import http from "node:http";
import { copyFile, mkdir, readFile, rm, writeFile } from "node:fs/promises";
import fs from "node:fs";
import path from "node:path";
import { TextDecoder } from "node:util";
import { fileURLToPath } from "node:url";

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
const ADMIN_BASE_PATH = "/__codex_retry_gateway";
const UI_PATH = `${ADMIN_BASE_PATH}/ui`;
const STATUS_API_PATH = `${ADMIN_BASE_PATH}/api/status`;
const CONFIG_API_PATH = `${ADMIN_BASE_PATH}/api/config`;
const LOGS_API_PATH = `${ADMIN_BASE_PATH}/api/logs`;
const RESTORE_API_PATH = `${ADMIN_BASE_PATH}/api/restore`;

const DEFAULT_CONFIG = {
  listen_host: "127.0.0.1",
  listen_port: 4610,
  upstream_base_url: "",
  request_body_limit_bytes: 10 * 1024 * 1024,
  endpoints: ["/responses", "/chat/completions", "/v1/responses", "/v1/chat/completions"],
  reasoning_equals: [516],
  non_stream_status_code: 502,
  stream_action: "strict_502",
  log_match: true,
  health_path: "/__codex_retry_gateway/health",
};

const REASONING_POINTERS = [
  "/usage/output_tokens_details/reasoning_tokens",
  "/usage/completion_tokens_details/reasoning_tokens",
  "/response/usage/output_tokens_details/reasoning_tokens",
  "/response/usage/completion_tokens_details/reasoning_tokens",
];

function parseArgs(argv) {
  const args = { config: null, log: null };
  for (let i = 2; i < argv.length; i += 1) {
    const current = argv[i];
    if (current === "--config") {
      args.config = argv[i + 1];
      i += 1;
    } else if (current === "--log") {
      args.log = argv[i + 1];
      i += 1;
    } else if (current === "--help" || current === "-h") {
      printHelp();
      process.exit(0);
    }
  }
  return args;
}

function printHelp() {
  process.stdout.write(
    [
      "用法:",
      "  node gateway.mjs --config <config.json> [--log <gateway.log>]",
      "",
      "说明:",
      "  独立 Codex 本地重试网关。",
      "  非流式命中 reasoning_tokens=516 时返回 502。",
      "  流式命中时默认缓存并返回 502，避免半截流返回。",
      "",
    ].join("\n"),
  );
}

function normalizePath(inputPath) {
  const [withoutQuery] = `${inputPath || "/"}`.split("?");
  const trimmed = withoutQuery.length > 1 ? withoutQuery.replace(/\/+$/, "") : withoutQuery;
  return trimmed || "/";
}

function flattenValues(value) {
  if (Array.isArray(value)) {
    return value.flatMap((item) => flattenValues(item));
  }
  return [value];
}

function isJsonContentType(contentType) {
  return `${contentType || ""}`.toLowerCase().includes("application/json");
}

function isSseContentType(contentType) {
  return `${contentType || ""}`.toLowerCase().includes("text/event-stream");
}

function jsonPointerGet(value, pointer) {
  if (!pointer.startsWith("/")) {
    return undefined;
  }
  return pointer
    .slice(1)
    .split("/")
    .map((segment) => segment.replace(/~1/g, "/").replace(/~0/g, "~"))
    .reduce((current, segment) => {
      if (current === null || current === undefined) {
        return undefined;
      }
      return current[segment];
    }, value);
}

function extractReasoningTokens(payload) {
  for (const pointer of REASONING_POINTERS) {
    const raw = jsonPointerGet(payload, pointer);
    if (Number.isInteger(raw)) {
      return raw;
    }
  }
  return null;
}

function normalizeIntegerList(values, fallback = []) {
  const source = values === undefined || values === null ? fallback : values;
  const normalized = flattenValues(source)
    .flatMap((value) => {
      if (typeof value === "string") {
        return value.split(/[\s,]+/).filter(Boolean);
      }
      return [value];
    })
    .map((value) => Number.parseInt(`${value}`, 10))
    .filter((value) => Number.isInteger(value));

  return [...new Set(normalized)];
}

function normalizeStringList(values, fallback = []) {
  const source = values === undefined || values === null ? fallback : values;
  const normalized = flattenValues(source)
    .flatMap((value) => `${value ?? ""}`.split(/[\s,]+/))
    .map((value) => value.trim())
    .filter(Boolean);

  return [...new Set(normalized)];
}

function buildBlockedBody(pathname, reasoning, statusCode) {
  return JSON.stringify({
    error: {
      message: `codex retry gateway blocked suspicious reasoning response on ${pathname}`,
      type: "codex_retry_gateway",
      code: "reasoning_guard_triggered",
      reasoning_tokens: reasoning,
      status_code: statusCode,
    },
  });
}

function buildGatewayErrorBody(message) {
  return JSON.stringify({
    error: {
      message,
      type: "codex_retry_gateway_error",
      code: "gateway_error",
    },
  });
}

function createMonitor() {
  return {
    started_at: new Date().toISOString(),
    next_log_seq: 1,
    log_entries: [],
    total_proxy_request_count: 0,
    inspected_response_count: 0,
    matched_response_count: 0,
    observed_reasoning_counts: {},
  };
}

function createMonitorRecorder(monitor) {
  return (message) => {
    const entry = {
      seq: monitor.next_log_seq,
      at: new Date().toISOString(),
      message,
    };
    monitor.next_log_seq += 1;
    monitor.log_entries.push(entry);
    return entry;
  };
}

function createLogger(logPath, recordEntry) {
  if (!logPath) {
    return (message) => {
      const entry = recordEntry ? recordEntry(message) : { at: new Date().toISOString(), message };
      process.stdout.write(`${entry.at} ${entry.message}\n`);
    };
  }

  const stream = fs.createWriteStream(logPath, { flags: "a" });
  return (message) => {
    const entry = recordEntry ? recordEntry(message) : { at: new Date().toISOString(), message };
    const line = `${entry.at} ${entry.message}\n`;
    stream.write(line);
    process.stdout.write(line);
  };
}

function incrementReasoningCount(counter, reasoning) {
  if (!Number.isInteger(reasoning)) {
    return;
  }
  const key = `${reasoning}`;
  counter[key] = (counter[key] || 0) + 1;
}

function recordInspectedResponse(monitor, reasoning, matched) {
  monitor.inspected_response_count += 1;
  incrementReasoningCount(monitor.observed_reasoning_counts, reasoning);
  if (matched) {
    monitor.matched_response_count += 1;
  }
}

function buildMetricsSnapshot(monitor) {
  const reasoning516Count = monitor.observed_reasoning_counts["516"] || 0;
  const inspectedResponseCount = monitor.inspected_response_count;
  return {
    started_at: monitor.started_at,
    total_proxy_request_count: monitor.total_proxy_request_count,
    inspected_response_count: inspectedResponseCount,
    matched_response_count: monitor.matched_response_count,
    reasoning_516_count: reasoning516Count,
    reasoning_516_ratio:
      inspectedResponseCount === 0 ? 0 : reasoning516Count / inspectedResponseCount,
    observed_reasoning_counts: { ...monitor.observed_reasoning_counts },
  };
}

function buildLogsSnapshot(monitor, sinceSeq = null) {
  const entries = Number.isInteger(sinceSeq)
    ? monitor.log_entries.filter((entry) => entry.seq > sinceSeq)
    : monitor.log_entries;

  return {
    total_entries: monitor.log_entries.length,
    latest_seq: monitor.next_log_seq - 1,
    entries,
  };
}

async function loadConfig(configPath) {
  const content = await readFile(configPath, "utf8");
  const loaded = JSON.parse(content);
  const config = { ...DEFAULT_CONFIG, ...loaded };
  config.endpoints = normalizeStringList(config.endpoints, DEFAULT_CONFIG.endpoints).map(normalizePath);
  config.reasoning_equals = normalizeIntegerList(
    config.reasoning_equals,
    DEFAULT_CONFIG.reasoning_equals,
  );
  if (!config.upstream_base_url) {
    throw new Error("配置缺少 upstream_base_url");
  }
  return config;
}

function buildRuntimePaths(configPath, logPath) {
  const configDirectory = path.dirname(configPath);
  const stateRoot = path.dirname(configDirectory);
  return {
    stateRoot,
    statePath: path.join(stateRoot, "state.json"),
    pidPath: path.join(stateRoot, "gateway.pid"),
    configPath,
    logPath,
  };
}

async function readOptionalJson(jsonPath) {
  try {
    const content = await readFile(jsonPath, "utf8");
    return JSON.parse(content);
  } catch {
    return null;
  }
}

async function writeConfig(configPath, config) {
  await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
}

function extractProviderBaseUrl(content, providerName) {
  if (!content || !providerName) {
    return null;
  }

  const sectionPattern = new RegExp(
    String.raw`^\[model_providers\.${providerName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\]\s*$[\s\S]*?(?=^\[|\Z)`,
    "m",
  );
  const sectionMatch = content.match(sectionPattern);
  if (!sectionMatch) {
    return null;
  }

  const baseUrlMatch = sectionMatch[0].match(/^\s*base_url\s*=\s*"([^"]+)"\s*$/m);
  return baseUrlMatch ? baseUrlMatch[1] : null;
}

async function readRuntimeState(runtime) {
  const state = await readOptionalJson(runtime.paths.statePath);
  if (!state) {
    return null;
  }

  let codexCurrentBaseUrl = null;
  if (state.codex_config_path && state.provider_name) {
    try {
      const codexConfig = await readFile(state.codex_config_path, "utf8");
      codexCurrentBaseUrl = extractProviderBaseUrl(codexConfig, state.provider_name);
    } catch {
      codexCurrentBaseUrl = null;
    }
  }

  return {
    ...state,
    codex_current_base_url: codexCurrentBaseUrl,
  };
}

async function restoreRuntimeState(runtime, state) {
  const backupPath = state?.latest_backup_path;
  const codexConfigPath = state?.codex_config_path;

  if (!backupPath || !fs.existsSync(backupPath)) {
    throw new Error(`未找到可恢复备份: ${backupPath || "unknown"}`);
  }
  if (!codexConfigPath) {
    throw new Error("安装状态里缺少 codex_config_path");
  }

  await copyFile(backupPath, codexConfigPath);
  await Promise.all([
    rm(runtime.paths.statePath, { force: true }),
    rm(runtime.paths.pidPath, { force: true }),
  ]);
}

function jsonResponse(res, statusCode, payload, headers = {}) {
  res.writeHead(statusCode, {
    "content-type": "application/json; charset=utf-8",
    ...headers,
  });
  res.end(JSON.stringify(payload));
}

function htmlResponse(res, html) {
  res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
  res.end(html);
}

function buildEditableConfig(currentConfig, payload) {
  const nextReasoning = normalizeIntegerList(payload.reasoning_equals, currentConfig.reasoning_equals);
  const nextEndpoints = normalizeStringList(payload.endpoints, currentConfig.endpoints).map(normalizePath);
  const nextStatusCode =
    payload.non_stream_status_code === undefined
      ? currentConfig.non_stream_status_code
      : Number.parseInt(`${payload.non_stream_status_code}`, 10);

  if (nextReasoning.length === 0) {
    throw new Error("reasoning_equals 不能为空");
  }
  if (nextEndpoints.length === 0) {
    throw new Error("endpoints 不能为空");
  }
  if (!Number.isInteger(nextStatusCode) || nextStatusCode < 100 || nextStatusCode > 599) {
    throw new Error("non_stream_status_code 必须是 100-599 的整数");
  }

  return {
    ...currentConfig,
    reasoning_equals: nextReasoning,
    endpoints: nextEndpoints,
    non_stream_status_code: nextStatusCode,
    log_match: payload.log_match === undefined ? currentConfig.log_match : Boolean(payload.log_match),
  };
}

function buildManagementHtml() {
  const uiConfig = {
    statusPath: STATUS_API_PATH,
    configPath: CONFIG_API_PATH,
    logsPath: LOGS_API_PATH,
    restorePath: RESTORE_API_PATH,
  };

  return `<!doctype html>
<html lang="zh-CN">
  <head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <title>Codex Retry Gateway</title>
    <style>
      :root {
        color-scheme: light;
        --bg: #f2ede3;
        --panel: rgba(255, 251, 245, 0.9);
        --panel-strong: #fffdf8;
        --ink: #1f1d1a;
        --muted: #6c655c;
        --accent: #1f6f5f;
        --accent-soft: #d9efe9;
        --warn: #a2512f;
        --line: rgba(31, 29, 26, 0.12);
        --shadow: 0 18px 40px rgba(47, 34, 14, 0.12);
      }

      * {
        box-sizing: border-box;
      }

      body {
        margin: 0;
        min-height: 100vh;
        font-family: "Segoe UI Variable", "Bahnschrift", "Segoe UI", sans-serif;
        color: var(--ink);
        background:
          radial-gradient(circle at top left, rgba(31, 111, 95, 0.22), transparent 34%),
          radial-gradient(circle at top right, rgba(162, 81, 47, 0.18), transparent 26%),
          linear-gradient(180deg, #f8f4ec 0%, var(--bg) 100%);
      }

      .shell {
        max-width: 1080px;
        margin: 0 auto;
        padding: 28px 18px 60px;
      }

      .hero {
        padding: 26px;
        border: 1px solid var(--line);
        border-radius: 28px;
        background: linear-gradient(135deg, rgba(255, 255, 255, 0.78), rgba(249, 242, 228, 0.92));
        box-shadow: var(--shadow);
      }

      .eyebrow {
        display: inline-flex;
        align-items: center;
        gap: 8px;
        padding: 6px 12px;
        border-radius: 999px;
        background: var(--accent-soft);
        color: var(--accent);
        font-size: 13px;
        font-weight: 700;
      }

      h1 {
        margin: 16px 0 8px;
        font-size: clamp(30px, 6vw, 48px);
        line-height: 1.05;
      }

      .lead {
        margin: 0;
        max-width: 720px;
        font-size: 16px;
        line-height: 1.7;
        color: var(--muted);
      }

      .grid {
        display: grid;
        gap: 18px;
        margin-top: 22px;
      }

      @media (min-width: 900px) {
        .grid {
          grid-template-columns: 1.1fr 0.9fr;
        }
      }

      .card {
        border: 1px solid var(--line);
        border-radius: 24px;
        background: var(--panel);
        box-shadow: var(--shadow);
        backdrop-filter: blur(10px);
      }

      .card-inner {
        padding: 22px;
      }

      .card h2 {
        margin: 0 0 14px;
        font-size: 18px;
      }

      .stats {
        display: grid;
        gap: 12px;
      }

      @media (min-width: 640px) {
        .stats {
          grid-template-columns: repeat(2, minmax(0, 1fr));
        }
      }

      .stat {
        padding: 14px;
        border-radius: 18px;
        background: var(--panel-strong);
        border: 1px solid rgba(31, 29, 26, 0.08);
      }

      .stat label {
        display: block;
        font-size: 12px;
        letter-spacing: 0.04em;
        text-transform: uppercase;
        color: var(--muted);
        margin-bottom: 6px;
      }

      .stat strong,
      .stat span {
        display: block;
        font-size: 15px;
        line-height: 1.5;
        word-break: break-word;
      }

      form {
        display: grid;
        gap: 16px;
      }

      .field {
        display: grid;
        gap: 8px;
      }

      .field label {
        font-weight: 700;
        font-size: 14px;
      }

      .hint {
        font-size: 12px;
        color: var(--muted);
        line-height: 1.5;
      }

      input,
      textarea,
      select {
        width: 100%;
        border: 1px solid rgba(31, 29, 26, 0.14);
        border-radius: 16px;
        padding: 12px 14px;
        font: inherit;
        color: var(--ink);
        background: #fffdfa;
      }

      textarea {
        min-height: 132px;
        resize: vertical;
      }

      .inline-toggle {
        display: flex;
        align-items: center;
        gap: 10px;
        padding: 12px 14px;
        border-radius: 16px;
        background: var(--panel-strong);
        border: 1px solid rgba(31, 29, 26, 0.08);
      }

      .actions {
        display: flex;
        flex-wrap: wrap;
        gap: 12px;
      }

      button {
        border: 0;
        border-radius: 999px;
        padding: 12px 18px;
        font: inherit;
        font-weight: 700;
        cursor: pointer;
      }

      .primary {
        color: white;
        background: linear-gradient(135deg, #236e60, #184f45);
      }

      .secondary {
        color: var(--warn);
        background: #fff4ee;
        border: 1px solid rgba(162, 81, 47, 0.2);
      }

      .message {
        min-height: 24px;
        font-size: 14px;
        line-height: 1.6;
      }

      .message[data-tone="error"] {
        color: #9e2f21;
      }

      .message[data-tone="success"] {
        color: var(--accent);
      }

      .footnote {
        margin-top: 12px;
        font-size: 13px;
        line-height: 1.6;
        color: var(--muted);
      }

      .wide-card {
        grid-column: 1 / -1;
      }

      .live-meta {
        margin: 0 0 12px;
        font-size: 13px;
        line-height: 1.6;
        color: var(--muted);
      }

      .log-output {
        margin: 0;
        min-height: 320px;
        max-height: 420px;
        overflow: auto;
        padding: 16px;
        border-radius: 18px;
        border: 1px solid rgba(31, 29, 26, 0.08);
        background: #1e1d1a;
        color: #f4efe7;
        font-family: "Cascadia Code", "Consolas", monospace;
        font-size: 12px;
        line-height: 1.6;
        white-space: pre-wrap;
        word-break: break-word;
      }

      code {
        font-family: "Cascadia Code", "Consolas", monospace;
        font-size: 0.92em;
      }
    </style>
  </head>
  <body>
    <div class="shell">
      <section class="hero">
        <div class="eyebrow">本地管理页</div>
        <h1>Codex Retry Gateway</h1>
        <p class="lead">
          这个页面直接挂在正在运行的 gateway 上。你可以在这里查看当前接管状态、修改 516 拦截条件，并一键恢复 Codex 原设置。
        </p>
      </section>

      <div class="grid">
        <section class="card">
          <div class="card-inner">
            <h2>运行状态</h2>
            <div class="stats">
              <div class="stat"><label>监听地址</label><strong id="listenValue">-</strong></div>
              <div class="stat"><label>真实上游</label><span id="upstreamValue">-</span></div>
              <div class="stat"><label>当前 Provider</label><span id="providerValue">-</span></div>
              <div class="stat"><label>当前 Codex Base URL</label><span id="codexBaseUrlValue">-</span></div>
              <div class="stat"><label>Config 文件</label><span id="configPathValue">-</span></div>
              <div class="stat"><label>备份文件</label><span id="backupPathValue">-</span></div>
              <div class="stat"><label>本次启动时间</label><span id="startedAtValue">-</span></div>
              <div class="stat"><label>代理请求总数</label><strong id="proxyRequestCountValue">0</strong></div>
              <div class="stat"><label>被检查响应总数</label><strong id="inspectedCountValue">0</strong></div>
              <div class="stat"><label>516 命中次数</label><strong id="reasoning516CountValue">0</strong></div>
              <div class="stat"><label>516 占比</label><strong id="reasoning516RatioValue">0.00%</strong></div>
              <div class="stat"><label>当前规则命中总数</label><strong id="matchedCountValue">0</strong></div>
            </div>
            <p class="footnote">
              如果“当前 Codex Base URL”已经是本机监听地址，就说明当前 Codex 已经被这个 gateway 接管。统计口径按本次 gateway 启动以来累计。
            </p>
          </div>
        </section>

        <section class="card">
          <div class="card-inner">
            <h2>拦截规则</h2>
            <form id="configForm">
              <div class="field">
                <label for="reasoningInput">reasoning_equals</label>
                <input id="reasoningInput" name="reasoning_equals" type="text" placeholder="例如：516, 1024" />
                <div class="hint">多个值用英文逗号或空格分隔。</div>
              </div>

              <div class="field">
                <label for="endpointsInput">endpoints</label>
                <textarea id="endpointsInput" name="endpoints" placeholder="/responses"></textarea>
                <div class="hint">每行一个路径。默认建议同时保留 root 与 /v1 两套路径。</div>
              </div>

              <div class="field">
                <label for="statusCodeInput">non_stream_status_code</label>
                <input id="statusCodeInput" name="non_stream_status_code" type="number" min="100" max="599" />
              </div>

              <div class="inline-toggle">
                <input id="logMatchInput" name="log_match" type="checkbox" />
                <label for="logMatchInput">log_match 命中时写日志</label>
              </div>

              <div class="actions">
                <button class="primary" id="saveButton" type="submit">保存并立即生效</button>
                <button class="secondary" id="restoreButton" type="button">恢复 Codex 原设置并关闭网关</button>
              </div>
            </form>
            <div class="message" id="messageBox"></div>
            <p class="footnote">
              点击“恢复”后，gateway 会停掉，所以这个页面会失联。这是预期行为，不是报错。
            </p>
          </div>
        </section>

        <section class="card wide-card">
          <div class="card-inner">
            <h2>实时日志</h2>
            <p class="live-meta" id="logsMeta">正在读取日志...</p>
            <pre class="log-output" id="logsOutput">正在读取日志...</pre>
          </div>
        </section>
      </div>
    </div>

    <script>
      const ui = ${JSON.stringify(uiConfig)};
      const refs = {
        form: document.getElementById('configForm'),
        reasoningInput: document.getElementById('reasoningInput'),
        endpointsInput: document.getElementById('endpointsInput'),
        statusCodeInput: document.getElementById('statusCodeInput'),
        logMatchInput: document.getElementById('logMatchInput'),
        saveButton: document.getElementById('saveButton'),
        restoreButton: document.getElementById('restoreButton'),
        messageBox: document.getElementById('messageBox'),
        listenValue: document.getElementById('listenValue'),
        upstreamValue: document.getElementById('upstreamValue'),
        providerValue: document.getElementById('providerValue'),
        codexBaseUrlValue: document.getElementById('codexBaseUrlValue'),
        configPathValue: document.getElementById('configPathValue'),
        backupPathValue: document.getElementById('backupPathValue'),
        startedAtValue: document.getElementById('startedAtValue'),
        proxyRequestCountValue: document.getElementById('proxyRequestCountValue'),
        inspectedCountValue: document.getElementById('inspectedCountValue'),
        reasoning516CountValue: document.getElementById('reasoning516CountValue'),
        reasoning516RatioValue: document.getElementById('reasoning516RatioValue'),
        matchedCountValue: document.getElementById('matchedCountValue'),
        logsMeta: document.getElementById('logsMeta'),
        logsOutput: document.getElementById('logsOutput'),
      };
      let hasLoadedForm = false;
      let lastLogSeq = 0;
      let pollTimer = null;
      let stoppedByRestore = false;

      function setMessage(text, tone) {
        refs.messageBox.textContent = text || '';
        refs.messageBox.dataset.tone = tone || '';
      }

      function formatTimestamp(value) {
        if (!value) {
          return '-';
        }
        const date = new Date(value);
        if (Number.isNaN(date.getTime())) {
          return value;
        }
        return date.toLocaleString('zh-CN', { hour12: false });
      }

      function formatPercent(value) {
        return Number.isFinite(value) ? (value * 100).toFixed(2) + '%' : '0.00%';
      }

      function parseReasoningInput() {
        return refs.reasoningInput.value
          .split(/[\\s,]+/)
          .map((value) => value.trim())
          .filter(Boolean)
          .map((value) => Number.parseInt(value, 10))
          .filter((value) => Number.isInteger(value));
      }

      function parseEndpointsInput() {
        return refs.endpointsInput.value
          .split(/\\r?\\n/)
          .map((value) => value.trim())
          .filter(Boolean);
      }

      function fillStatus(payload) {
        refs.listenValue.textContent = payload.listen || '-';
        refs.upstreamValue.textContent = payload.config?.upstream_base_url || '-';
        refs.providerValue.textContent = payload.state?.provider_name || '未检测到安装状态';
        refs.codexBaseUrlValue.textContent = payload.state?.codex_current_base_url || '-';
        refs.configPathValue.textContent = payload.paths?.config_path || '-';
        refs.backupPathValue.textContent = payload.state?.latest_backup_path || '-';
        fillMetrics(payload.metrics || {});
      }

      function fillMetrics(metrics) {
        refs.startedAtValue.textContent = formatTimestamp(metrics.started_at);
        refs.proxyRequestCountValue.textContent = String(metrics.total_proxy_request_count ?? 0);
        refs.inspectedCountValue.textContent = String(metrics.inspected_response_count ?? 0);
        refs.reasoning516CountValue.textContent = String(metrics.reasoning_516_count ?? 0);
        refs.reasoning516RatioValue.textContent = formatPercent(metrics.reasoning_516_ratio ?? 0);
        refs.matchedCountValue.textContent = String(metrics.matched_response_count ?? 0);
      }

      function fillForm(config) {
        refs.reasoningInput.value = Array.isArray(config?.reasoning_equals) ? config.reasoning_equals.join(', ') : '';
        refs.endpointsInput.value = Array.isArray(config?.endpoints) ? config.endpoints.join('\\n') : '';
        refs.statusCodeInput.value = config?.non_stream_status_code ?? 502;
        refs.logMatchInput.checked = Boolean(config?.log_match);
      }

      function renderLogs(payload, replaceAll) {
        const entries = Array.isArray(payload?.entries) ? payload.entries : [];
        const rendered = entries
          .map((entry) => {
            const at = entry?.at ? entry.at : '-';
            const message = entry?.message ? entry.message : '';
            return at + ' ' + message;
          })
          .join('\\n');

        if (replaceAll) {
          refs.logsOutput.textContent = rendered || '当前还没有日志。';
        } else if (rendered) {
          const current = refs.logsOutput.textContent.trim();
          refs.logsOutput.textContent = current ? current + '\\n' + rendered : rendered;
        }

        if (!rendered && replaceAll) {
          refs.logsOutput.textContent = '当前还没有日志。';
        }

        refs.logsMeta.textContent =
          '已载入 ' +
          String(payload?.total_entries ?? entries.length) +
          ' 条日志，最新序号 ' +
          String(payload?.latest_seq ?? lastLogSeq) +
          '。';
        refs.logsOutput.scrollTop = refs.logsOutput.scrollHeight;
        if (Number.isInteger(payload?.latest_seq)) {
          lastLogSeq = payload.latest_seq;
        }
      }

      async function loadLogs(incremental) {
        const url = new URL(ui.logsPath, window.location.origin);
        if (incremental && lastLogSeq > 0) {
          url.searchParams.set('since_seq', String(lastLogSeq));
        }
        const response = await fetch(url.toString(), { cache: 'no-store' });
        const payload = await response.json();
        if (!response.ok) {
          throw new Error(payload?.error?.message || '读取日志失败');
        }
        renderLogs(payload, !incremental || lastLogSeq === 0);
      }

      async function loadStatus(options) {
        const refreshForm = Boolean(options?.refreshForm);
        const response = await fetch(ui.statusPath);
        const payload = await response.json();
        if (!response.ok) {
          throw new Error(payload?.error?.message || '读取状态失败');
        }
        fillStatus(payload);
        if (refreshForm || !hasLoadedForm) {
          fillForm(payload.config || {});
          hasLoadedForm = true;
        }
      }

      async function saveConfig(event) {
        event.preventDefault();
        refs.saveButton.disabled = true;
        setMessage('正在保存配置...', '');

        try {
          const response = await fetch(ui.configPath, {
            method: 'POST',
            headers: { 'content-type': 'application/json' },
            body: JSON.stringify({
              reasoning_equals: parseReasoningInput(),
              endpoints: parseEndpointsInput(),
              non_stream_status_code: Number.parseInt(refs.statusCodeInput.value, 10),
              log_match: refs.logMatchInput.checked,
            }),
          });
          const payload = await response.json();
          if (!response.ok) {
            throw new Error(payload?.error?.message || '保存失败');
          }
          fillStatus(payload);
          fillForm(payload.config || {});
          hasLoadedForm = true;
          await loadLogs(false);
          setMessage('配置已保存，并已对当前 gateway 立即生效。', 'success');
        } catch (error) {
          setMessage(error?.message || String(error), 'error');
        } finally {
          refs.saveButton.disabled = false;
        }
      }

      async function restoreConfig() {
        if (!window.confirm('恢复后会关闭当前 gateway，并把 Codex 配置切回原上游。确定继续吗？')) {
          return;
        }

        refs.restoreButton.disabled = true;
        stoppedByRestore = true;
        if (pollTimer) {
          window.clearInterval(pollTimer);
        }
        setMessage('正在触发恢复，页面很快会失联...', '');

        try {
          const response = await fetch(ui.restorePath, {
            method: 'POST',
            headers: { 'content-type': 'application/json' },
            body: JSON.stringify({}),
          });
          const payload = await response.json();
          if (!response.ok) {
            throw new Error(payload?.error?.message || '恢复失败');
          }
          setMessage('恢复脚本已启动，等待 gateway 关闭。', 'success');
        } catch (error) {
          setMessage(error?.message || String(error), 'error');
          refs.restoreButton.disabled = false;
          return;
        }

        window.setTimeout(async () => {
          try {
            await fetch(ui.statusPath, { cache: 'no-store' });
          } catch {
            setMessage('gateway 已关闭，Codex 原设置应已恢复。', 'success');
          }
        }, 1200);
      }

      async function refreshLiveData() {
        if (stoppedByRestore) {
          return;
        }
        await Promise.all([
          loadStatus({ refreshForm: false }),
          loadLogs(true),
        ]);
      }

      refs.form.addEventListener('submit', saveConfig);
      refs.restoreButton.addEventListener('click', restoreConfig);

      Promise.all([
        loadStatus({ refreshForm: true }),
        loadLogs(false),
      ])
        .then(() => {
          pollTimer = window.setInterval(() => {
            refreshLiveData().catch((error) => {
              if (!stoppedByRestore) {
                setMessage(error?.message || String(error), 'error');
              }
            });
          }, 2000);
        })
        .catch((error) => {
          setMessage(error?.message || String(error), 'error');
        });
    </script>
  </body>
</html>`;
}

async function handleManagementRequest(runtime, req, res, requestUrl) {
  const pathname = normalizePath(requestUrl.pathname);

  if (pathname === UI_PATH) {
    htmlResponse(res, buildManagementHtml());
    return true;
  }

  if (pathname === STATUS_API_PATH && req.method === "GET") {
    const state = await readRuntimeState(runtime);
    jsonResponse(res, 200, {
      ok: true,
      listen: `${runtime.config.listen_host}:${runtime.config.listen_port}`,
      config: runtime.config,
      state,
      paths: {
        config_path: runtime.configPath,
        state_path: runtime.paths.statePath,
        state_root: runtime.paths.stateRoot,
        log_path: runtime.logPath,
      },
      metrics: buildMetricsSnapshot(runtime.monitor),
    });
    return true;
  }

  if (pathname === LOGS_API_PATH && req.method === "GET") {
    const sinceSeqRaw = requestUrl.searchParams.get("since_seq");
    const sinceSeq = sinceSeqRaw === null ? null : Number.parseInt(sinceSeqRaw, 10);
    jsonResponse(res, 200, {
      ok: true,
      ...buildLogsSnapshot(runtime.monitor, Number.isInteger(sinceSeq) ? sinceSeq : null),
    });
    return true;
  }

  if (pathname === CONFIG_API_PATH && req.method === "POST") {
    const body = await readRequestBody(req, runtime.config.request_body_limit_bytes);
    const payload = parseJsonSafely(body);
    if (!payload) {
      jsonResponse(res, 400, {
        error: {
          message: "配置保存请求必须是有效 JSON",
          code: "invalid_json",
        },
      });
      return true;
    }

    const nextConfig = buildEditableConfig(runtime.config, payload);
    await writeConfig(runtime.configPath, nextConfig);
    runtime.config = nextConfig;
    runtime.logger(
      `[config] updated reasoning_equals=${nextConfig.reasoning_equals.join(",")} endpoints=${nextConfig.endpoints.join(",")}`,
    );
    const state = await readRuntimeState(runtime);
    jsonResponse(res, 200, {
      ok: true,
      message: "配置已保存并立即生效",
      config: runtime.config,
      state,
      paths: {
        config_path: runtime.configPath,
        state_path: runtime.paths.statePath,
        state_root: runtime.paths.stateRoot,
        log_path: runtime.logPath,
      },
      metrics: buildMetricsSnapshot(runtime.monitor),
    });
    return true;
  }

  if (pathname === RESTORE_API_PATH && req.method === "POST") {
    const state = await readRuntimeState(runtime);
    if (!state) {
      jsonResponse(res, 409, {
        error: {
          message: "当前未检测到安装状态，无法恢复 Codex 原设置",
          code: "state_not_found",
        },
      });
      return true;
    }

    await restoreRuntimeState(runtime, state);
    runtime.logger(`[restore] restored via UI state_root=${runtime.paths.stateRoot}`);
    jsonResponse(res, 202, {
      ok: true,
      message: "原设置已恢复，gateway 即将关闭",
    });
    res.on("finish", () => {
      const exitTimer = setTimeout(() => {
        if (runtime.server) {
          runtime.server.close(() => {
            process.exit(0);
          });
        } else {
          process.exit(0);
        }

        const hardExitTimer = setTimeout(() => {
          process.exit(0);
        }, 600);
        hardExitTimer.unref();
      }, 120);
      exitTimer.unref();
    });
    return true;
  }

  return false;
}

function buildUpstreamUrl(baseUrl, requestUrl) {
  const upstream = new URL(baseUrl);
  const normalizedBasePath = upstream.pathname.endsWith("/")
    ? upstream.pathname.slice(0, -1)
    : upstream.pathname;
  const incomingPath = requestUrl.pathname;

  let finalPath = incomingPath;
  if (normalizedBasePath && normalizedBasePath !== "/") {
    if (incomingPath.startsWith(`${normalizedBasePath}/`) || incomingPath === normalizedBasePath) {
      finalPath = incomingPath;
    } else if (normalizedBasePath.endsWith("/v1") && incomingPath.startsWith("/v1/")) {
      finalPath = `${normalizedBasePath}${incomingPath.slice(3)}`;
    } else {
      finalPath = `${normalizedBasePath}${incomingPath}`;
    }
  }

  upstream.pathname = finalPath;
  upstream.search = requestUrl.search;
  return upstream.toString();
}

function cloneHeadersForUpstream(headers) {
  const outgoing = new Headers();
  for (const [key, value] of Object.entries(headers)) {
    if (value === undefined) {
      continue;
    }
    const lowerKey = key.toLowerCase();
    if (
      lowerKey === "host" ||
      lowerKey === "content-length" ||
      lowerKey === "connection" ||
      lowerKey === "transfer-encoding"
    ) {
      continue;
    }
    if (Array.isArray(value)) {
      for (const item of value) {
        outgoing.append(key, item);
      }
    } else {
      outgoing.set(key, value);
    }
  }
  return outgoing;
}

function copyHeadersToClient(sourceHeaders, target) {
  for (const [key, value] of sourceHeaders.entries()) {
    const lowerKey = key.toLowerCase();
    if (
      lowerKey === "content-length" ||
      lowerKey === "transfer-encoding" ||
      lowerKey === "content-encoding" ||
      lowerKey === "connection"
    ) {
      continue;
    }
    target.setHeader(key, value);
  }
}

async function readRequestBody(req, limitBytes) {
  const chunks = [];
  let total = 0;
  for await (const chunk of req) {
    total += chunk.length;
    if (total > limitBytes) {
      throw new Error(`请求体超过限制: ${limitBytes} bytes`);
    }
    chunks.push(chunk);
  }
  return Buffer.concat(chunks);
}

function parseJsonSafely(buffer) {
  try {
    return JSON.parse(buffer.toString("utf8"));
  } catch {
    return null;
  }
}

function matchPath(config, pathname) {
  return config.endpoints.includes(normalizePath(pathname));
}

function reasoningMatched(config, reasoning) {
  return reasoning !== null && config.reasoning_equals.includes(reasoning);
}

function isExpectedStreamTermination(error) {
  if (!error) {
    return false;
  }
  if (error.name === "AbortError") {
    return true;
  }
  return error instanceof TypeError && error.message === "terminated";
}

function isRetryableUpstreamFetchError(error) {
  if (!error) {
    return false;
  }
  return error instanceof TypeError && error.message === "fetch failed";
}

async function fetchUpstreamWithRetry(upstreamUrl, init, logger) {
  const maxAttempts = 2;
  let lastError = null;

  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
    try {
      return await fetch(upstreamUrl, init);
    } catch (error) {
      lastError = error;
      if (!isRetryableUpstreamFetchError(error) || attempt === maxAttempts) {
        break;
      }
      logger?.(`[retry] upstream fetch failed attempt=${attempt} url=${upstreamUrl}`);
    }
  }

  throw lastError;
}

function inspectSseChunk(state, chunk) {
  const decoded = state.decoder.decode(chunk, { stream: true });
  state.buffer += decoded;

  const blocks = state.buffer.split(/\r?\n\r?\n/);
  state.buffer = blocks.pop() ?? "";

  for (const block of blocks) {
    const lines = block
      .split(/\r?\n/)
      .map((line) => line.trimEnd())
      .filter(Boolean);
    const dataLines = lines
      .filter((line) => line.startsWith("data:"))
      .map((line) => line.replace(/^data:\s?/, ""));

    if (dataLines.length === 0) {
      continue;
    }
    const payloadText = dataLines.join("\n");
    if (payloadText === "[DONE]") {
      continue;
    }
    try {
      const parsed = JSON.parse(payloadText);
      const reasoning = extractReasoningTokens(parsed);
      if (reasoning !== null) {
        return reasoning;
      }
    } catch {
      // ignore malformed SSE payloads
    }
  }
  return null;
}

async function handleNonStreaming({
  config,
  logger,
  monitor,
  pathname,
  upstreamResponse,
  res,
}) {
  const bodyBuffer = Buffer.from(await upstreamResponse.arrayBuffer());
  const parsed = isJsonContentType(upstreamResponse.headers.get("content-type"))
    ? parseJsonSafely(bodyBuffer)
    : null;
  const reasoning = parsed ? extractReasoningTokens(parsed) : null;
  const matched = reasoningMatched(config, reasoning);

  recordInspectedResponse(monitor, reasoning, matched);

  if (matched) {
    if (config.log_match) {
      logger(
        `[match] non-stream path=${pathname} reasoning_tokens=${reasoning} action=status_${config.non_stream_status_code}`,
      );
    }
    const blockedBody = buildBlockedBody(pathname, reasoning, config.non_stream_status_code);
    res.writeHead(config.non_stream_status_code, {
      "content-type": "application/json; charset=utf-8",
      "x-codex-retry-gateway-reason": "reasoning-guard-triggered",
    });
    res.end(blockedBody);
    return;
  }

  copyHeadersToClient(upstreamResponse.headers, res);
  res.writeHead(upstreamResponse.status);
  res.end(bodyBuffer);
}

async function handleStreaming({
  config,
  logger,
  monitor,
  pathname,
  upstreamResponse,
  res,
  abortController,
}) {
  const strict502Mode = config.stream_action !== "disconnect";
  const reader = upstreamResponse.body.getReader();
  const sseState = {
    decoder: new TextDecoder("utf8"),
    buffer: "",
  };

  let wroteAnyChunk = false;
  let observedReasoning = null;
  const bufferedChunks = [];

  if (!strict502Mode) {
    copyHeadersToClient(upstreamResponse.headers, res);
    res.writeHead(upstreamResponse.status);
  }

  while (true) {
    let readResult;
    try {
      readResult = await reader.read();
    } catch (error) {
      if (isExpectedStreamTermination(error)) {
        recordInspectedResponse(monitor, observedReasoning, false);
        if (strict502Mode) {
          logger?.(`[stream] upstream terminated before completion path=${pathname} action=status_502`);
          res.writeHead(502, { "content-type": "application/json; charset=utf-8" });
          res.end(buildGatewayErrorBody("upstream stream terminated before completion"));
        } else {
          res.end();
        }
        return;
      }
      throw error;
    }

    const { done, value } = readResult;
    if (done) {
      recordInspectedResponse(monitor, observedReasoning, false);
      if (strict502Mode) {
        copyHeadersToClient(upstreamResponse.headers, res);
        res.writeHead(upstreamResponse.status);
        res.end(Buffer.concat(bufferedChunks));
      } else {
        res.end();
      }
      return;
    }

    const chunkBuffer = Buffer.from(value);
    const reasoning = inspectSseChunk(sseState, value);
    if (Number.isInteger(reasoning)) {
      observedReasoning = reasoning;
    }
    if (reasoningMatched(config, reasoning)) {
      recordInspectedResponse(monitor, reasoning, true);
      if (config.log_match) {
        logger(
          `[match] stream path=${pathname} reasoning_tokens=${reasoning} action=${config.stream_action}`,
        );
      }

      if (strict502Mode || !wroteAnyChunk) {
        abortController.abort();
        reader.cancel().catch(() => {});
        const blockedBody = buildBlockedBody(pathname, reasoning, config.non_stream_status_code);
        res.writeHead(config.non_stream_status_code, {
          "content-type": "application/json; charset=utf-8",
          "x-codex-retry-gateway-reason": "reasoning-guard-triggered",
        });
        res.end(blockedBody);
      } else {
        abortController.abort();
        reader.cancel().catch(() => {});
        res.socket?.destroy();
      }
      return;
    }

    if (strict502Mode) {
      bufferedChunks.push(chunkBuffer);
    } else {
      wroteAnyChunk = true;
      res.write(chunkBuffer);
    }
  }
}

async function proxyRequest(runtime, req, res) {
  const { logger } = runtime;
  const config = runtime.config;
  const incomingUrl = new URL(req.url, `http://${req.headers.host || "127.0.0.1"}`);
  const pathname = normalizePath(incomingUrl.pathname);

  if (pathname === config.health_path) {
    res.writeHead(200, { "content-type": "application/json; charset=utf-8" });
    res.end(
      JSON.stringify({
        ok: true,
        listen: `${config.listen_host}:${config.listen_port}`,
        upstream_base_url: config.upstream_base_url,
        ui_path: UI_PATH,
      }),
    );
    return;
  }

  if (await handleManagementRequest(runtime, req, res, incomingUrl)) {
    return;
  }

  runtime.monitor.total_proxy_request_count += 1;

  const requestBody = await readRequestBody(req, config.request_body_limit_bytes);
  const requestJson = isJsonContentType(req.headers["content-type"])
    ? parseJsonSafely(requestBody)
    : null;
  const requestIsStream = Boolean(requestJson?.stream);

  const upstreamUrl = buildUpstreamUrl(config.upstream_base_url, incomingUrl);
  const abortController = new AbortController();

  const upstreamResponse = await fetchUpstreamWithRetry(upstreamUrl, {
    method: req.method,
    headers: cloneHeadersForUpstream(req.headers),
    body: requestBody.length > 0 ? requestBody : undefined,
    signal: abortController.signal,
  }, logger);

  const shouldInspect = matchPath(config, pathname);
  const responseIsStream =
    requestIsStream || isSseContentType(upstreamResponse.headers.get("content-type"));

  if (!shouldInspect) {
    copyHeadersToClient(upstreamResponse.headers, res);
    res.writeHead(upstreamResponse.status);
    const body = Buffer.from(await upstreamResponse.arrayBuffer());
    res.end(body);
    return;
  }

  if (responseIsStream) {
    await handleStreaming({
      config,
      logger,
      monitor: runtime.monitor,
      pathname,
      upstreamResponse,
      res,
      abortController,
    });
    return;
  }

  await handleNonStreaming({
    config,
    logger,
    monitor: runtime.monitor,
    pathname,
    upstreamResponse,
    res,
  });
}

async function main() {
  const args = parseArgs(process.argv);
  const configPath = args.config || path.join(__dirname, "config.json");
  const config = await loadConfig(configPath);
  const monitor = createMonitor();

  if (args.log) {
    await mkdir(path.dirname(args.log), { recursive: true });
  }
  const logger = createLogger(args.log, createMonitorRecorder(monitor));
  const runtime = {
    config,
    configPath,
    logPath: args.log || null,
    logger,
    monitor,
    paths: buildRuntimePaths(configPath, args.log || null),
    server: null,
  };

  const server = http.createServer(async (req, res) => {
    try {
      await proxyRequest(runtime, req, res);
    } catch (error) {
      logger(`[error] ${error?.stack || error}`);
      if (!res.headersSent) {
        res.writeHead(502, { "content-type": "application/json; charset=utf-8" });
        res.end(
          JSON.stringify({
            error: {
              message: `${error?.message || error}`,
              type: "codex_retry_gateway_error",
              code: "gateway_error",
            },
          }),
        );
      } else {
        res.socket?.destroy();
      }
    }
  });
  runtime.server = server;

  server.listen(config.listen_port, config.listen_host, () => {
    logger(
      `[start] codex retry gateway listening on http://${config.listen_host}:${config.listen_port} -> ${config.upstream_base_url}`,
    );
  });
}

main().catch((error) => {
  process.stderr.write(`${error?.stack || error}\n`);
  process.exit(1);
});