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

// 真实服务隔离回归，不读取或修改生产会话。
const assert = require('node:assert/strict');
const fs = require('node:fs');
const net = require('node:net');
const os = require('node:os');
const path = require('node:path');
const { spawn } = require('node:child_process');
const { WebSocket } = require('ws');
const { createSessionHistoryStore } = require('../lib/session-history-store');
const REPO = path.resolve(__dirname, '..');
const PASSWORD = 'SessionHttpFixture!234';
const STREAM = 'HTTP 夹具正在运行的完整输出';
const A = 'http-switch-a';
const B = 'http-switch-b';
const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
async function waitFor(fn, label, timeout = 10000) {
  const started = Date.now();
  let lastError;
  while (Date.now() - started < timeout) {
    try { const result = await fn(); if (result) return result; } catch (error) { lastError = error; }
    await sleep(40);
  }
  throw new Error(label + (lastError ? '：' + lastError.message : ''));
}
async function freePort() {
  const listener = net.createServer();
  await new Promise(resolve => listener.listen(0, '127.0.0.1', resolve));
  const port = listener.address().port;
  await new Promise(resolve => listener.close(resolve));
  return port;
}
async function stopChild(child) {
  if (!child || child.exitCode !== null || child.signalCode) return;
  const exited = new Promise(resolve => child.once('exit', resolve));
  child.kill('SIGTERM');
  await Promise.race([exited, sleep(500)]);
  if (child.exitCode === null && !child.signalCode) { child.kill('SIGKILL'); await exited; }
}
async function connect(port) {
  const ws = new WebSocket('ws://127.0.0.1:' + port + '/ws');
  const messages = [];
  ws.on('message', data => messages.push(JSON.parse(String(data))));
  await new Promise((resolve, reject) => { ws.once('open', resolve); ws.once('error', reject); });
  ws.send(JSON.stringify({ type: 'auth', password: PASSWORD }));
  const auth = await waitFor(() => messages.find(msg => msg.type === 'auth_result'), '隔离登录超时');
  assert(auth.success);
  return { ws, messages, token: auth.token };
}
function createFixture(root) {
  const sessionsDir = path.join(root, 'sessions');
  const homeDir = path.join(root, 'home');
  fs.mkdirSync(sessionsDir, { recursive: true });
  fs.mkdirSync(homeDir, { recursive: true });
  const store = createSessionHistoryStore({ sessionsDir, chunkMaxMessages: 8 });
  function seed(id, count = 57) {
    const now = new Date().toISOString();
    const session = { id, agent: 'codexapp', title: id, cwd: homeDir, created: now, updated: now,
      permissionMode: 'yolo', hasUnread: false,
      messages: Array.from({ length: count }, (_, index) => ({ id: id + '-' + index,
        role: index % 2 ? 'assistant' : 'user', content: id + ' 保存消息 ' + index, timestamp: now })) };
    store.save(session);
    fs.writeFileSync(path.join(sessionsDir, id + '.json'), JSON.stringify(session));
    return session;
  }
  seed(A); seed(B); seed('http-corrupt-chunk'); seed('http-corrupt-manifest');
  const corruptPath = path.join(sessionsDir, '_history', 'http-corrupt-chunk');
  const manifest = JSON.parse(fs.readFileSync(path.join(corruptPath, 'manifest.json'), 'utf8'));
  fs.writeFileSync(path.join(corruptPath, 'chunks', manifest.entries.at(-1).file), '{破损块');
  fs.writeFileSync(path.join(sessionsDir, '_history', 'http-corrupt-manifest', 'manifest.json'), '{破损清单');
  const legacy = { ...seed('http-legacy'), id: 'http-legacy-only' };
  fs.writeFileSync(path.join(sessionsDir, legacy.id + '.json'), JSON.stringify(legacy));

  // 原生目录也隔离，不覆写 HOME 等系统变量。
  const preload = path.join(root, 'isolated-home.cjs');
  fs.writeFileSync(preload, [
    "const fs = require('node:fs'); const Module = require('node:module');",
    "require('node:os').homedir = () => " + JSON.stringify(homeDir) + ';',
    // worker 也继承 preload；独立锁路径避免等待生产 app-server 的锁。
    'const locks = require(' + JSON.stringify(path.join(REPO, 'lib/codex-home-lock')) + ');',
    'const acquire = locks.acquireCodexHomeLock;',
    'locks.acquireCodexHomeLock = (options = {}) => acquire({ ...options, lockPath: ' + JSON.stringify(path.join(root, 'codex-fixture.lock')) + ' });',
    "const originalLoader = Module._extensions['.js'];",
    "Module._extensions['.js'] = (module, filename) => {",
    'if (filename !== ' + JSON.stringify(path.join(REPO, 'server.js')) + ') return originalLoader(module, filename);',
    "const source = fs.readFileSync(filename, 'utf8');",
    "const original = " + JSON.stringify("const CODEX_SESSIONS_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '', '.codex', 'sessions');") + ';',
    "if (!source.includes(original)) throw new Error('测试隔离目录注入点已变更');",
    'module._compile(source.replace(original, ' + JSON.stringify('const CODEX_SESSIONS_DIR = ' + JSON.stringify(path.join(homeDir, '.codex', 'sessions')) + ';') + '), filename); };',
  ].join('\n'));
  const completeFlag = path.join(root, 'complete-turn');
  const mockPath = path.join(root, 'mock-codex.js');
  const mock = fs.readFileSync(path.join(REPO, 'scripts/mock-codex-app-server.js'), 'utf8');
  const timer = 'thread.timer = setTimeout(() => completeTurn(thread, turnId, text), delay);';
  assert(mock.includes(timer));
  fs.writeFileSync(mockPath, mock.replace(timer, [
    "send({method:'item/agentMessage/delta',params:{threadId:thread.id,turnId,itemId:'agent-msg',delta:" + JSON.stringify(STREAM) + '}});',
    "thread.timer = setInterval(() => { if (!require('fs').existsSync(" + JSON.stringify(completeFlag) + ')) return;',
    'clearInterval(thread.timer); completeTurn(thread, turnId, text); }, 50);',
  ].join('\n')));
  fs.chmodSync(mockPath, 0o700);
  return { sessionsDir, homeDir, store, preload, completeFlag, mockPath };
}
async function runApi(port, fixture) {
  let connection = await connect(port);
  try {
  const token = connection.token;
  const closed = new Promise(resolve => connection.ws.once('close', resolve));
  connection.ws.close();
  await closed;
  let sequence = 0;
  async function query(id, suffix = '', authenticated = true) {
    const requestId = 'api-' + ++sequence;
    const separator = suffix.includes('?') ? '&' : '?';
    const response = await fetch('http://127.0.0.1:' + port + '/api/sessions/' + id + suffix + separator + 'requestId=' + requestId, {
      headers: authenticated ? { Authorization: 'Bearer ' + token } : {},
    });
    const payload = await response.json();
    assert.equal(payload.requestId, requestId);
    return { response, payload };
  }
  const first = await query(B);
  assert.equal(first.response.status, 200);
  assert.equal(first.payload.messages.length, 12);
  assert.equal(first.payload.historyCursor, 45);
  assert(first.response.headers.get('server-timing'));
  const ids = first.payload.messages.map(message => message.id);
  let cursor = first.payload.historyCursor;
  while (cursor > 0) {
    const page = await query(B, '/history?before=' + cursor);
    assert.equal(page.response.status, 200);
    assert(page.payload.messages.length <= 24);
    ids.unshift(...page.payload.messages.map(message => message.id));
    cursor = page.payload.historyCursor;
  }
  assert.deepEqual(ids, Array.from({ length: 57 }, (_, index) => B + '-' + index));
  assert.equal((await query(B, '', false)).response.status, 401);
  assert.equal((await query('does-not-exist')).response.status, 404);
  assert.equal((await query('bad%2Fid')).response.status, 400);
  assert.equal((await query('http_switch-a')).response.status, 400, '非法 ID 不能经 sanitizeId 别名到另一会话');
  assert.equal((await query('%ZZ')).response.status, 400);
  assert.equal((await query(B, '/history?before=-1')).response.status, 400);
  assert.equal((await query(B, '/history?before=1.5')).response.status, 400);
  for (const id of ['http-corrupt-chunk', 'http-corrupt-manifest']) {
    const result = await query(id);
    assert.equal(result.response.status, 500);
    assert.equal(result.payload.code, 'history_read_failed');
    assert.equal(result.payload.sessionId, id);
  }
  assert.equal((await query('http-legacy-only')).payload.messages.length, 12);
  connection = await connect(port);
  connection.ws.send(JSON.stringify({ type: 'subscribe_session', sessionId: B,
    requestId: 'subscribe-before-commit', historyRevision: first.payload.historyRevision }));
  const unchanged = await waitFor(() => connection.messages.find(msg => msg.requestId === 'subscribe-before-commit'), '订阅结果缺失');
  assert.equal(unchanged.type, 'session_subscribed');
  assert.equal(unchanged.historyChanged, false);
  assert.equal(unchanged.messages, undefined, '实时订阅不能重发历史');
  const changed = fixture.store.loadMetadata(B);
  changed.messages.push({ id: 'http-new-between-query-and-subscribe', role: 'assistant', content: '订阅间隙的新消息' });
  fixture.store.save(changed);
  connection.ws.send(JSON.stringify({ type: 'subscribe_session', sessionId: B,
    requestId: 'subscribe-after-commit', historyRevision: first.payload.historyRevision }));
  const advanced = await waitFor(() => connection.messages.find(msg => msg.requestId === 'subscribe-after-commit'), '新修订订阅结果缺失');
  assert.equal(advanced.historyChanged, true);
  assert.equal(advanced.messages, undefined);
  assert.equal((await query(B)).payload.messages.at(-1).id, 'http-new-between-query-and-subscribe');
  connection.ws.send(JSON.stringify({ type: 'message', sessionId: A, agent: 'codexapp', mode: 'yolo', text: 'HTTP 会话切换运行夹具' }));
  const running = await waitFor(async () => {
    const result = await query(A);
    return result.payload.isRunning && result.payload.runtime?.text.includes(STREAM) ? result.payload : null;
  }, 'HTTP 运行态快照缺失');
  assert.equal(running.historyPending, false);
  assert.equal(running.messages.length, 12);
  assert.equal(running.runtime.type, 'resume_generating');
  assert(!connection.messages.some(msg => msg.type === 'session_history_chunk'));
  return { connection, token, query };
  } catch (error) {
    connection.ws.terminate();
    throw error;
  }
}
async function main() {
  await require('./session-http-load-frontend-unit').runFrontendUnit();
  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-web-session-http-'));
  const fixture = createFixture(root);
  const port = await freePort();
  const server = spawn(process.execPath, ['-r', fixture.preload, path.join(REPO, 'server.js')], {
    cwd: REPO, env: { ...process.env, PORT: String(port), CC_WEB_PASSWORD: PASSWORD,
      CC_WEB_INTERNAL_MCP_TOKEN: 'HttpFixtureMcp!234', CC_WEB_TASK_BOARD_ENABLED: '0',
      CC_WEB_CONFIG_DIR: path.join(root, 'config'), CC_WEB_LOGS_DIR: path.join(root, 'logs'),
      CC_WEB_SESSIONS_DIR: fixture.sessionsDir, CODEX_PATH: fixture.mockPath,
      CLAUDE_PATH: path.join(REPO, 'scripts/mock-claude.js'),
    }, stdio: ['ignore', 'pipe', 'pipe'],
  });
  const log = fs.createWriteStream(path.join(root, 'server.log'));
  server.stdout.pipe(log); server.stderr.pipe(log);
  let api;
  try {
    await waitFor(async () => (await fetch('http://127.0.0.1:' + port + '/')).ok, '隔离服务启动失败');
    api = await runApi(port, fixture);
    console.log('HTTP 接口通过：WS 关闭后首屏12条、分页24条、顺序、鉴权、请求级错误、独立订阅、修订及运行快照');
    if (process.argv.includes('--browser')) {
      await require('./session-http-load-browser').runBrowser({ port, fixture, root, query: api.query,
        A, B, PASSWORD, STREAM, waitFor, freePort, stopChild, sleep });
    }
    const processLog = fs.readFileSync(path.join(root, 'logs', 'process.log'), 'utf8');
    assert(processLog.includes('session_http_query'));
    assert(processLog.includes('session_http_query_failed'));
    assert(!processLog.includes(STREAM), '诊断日志不得记录消息正文');
    console.log('HTTP 耗时诊断通过；隔离证据：' + root);
  } finally {
    if (api) api.connection.ws.terminate();
    await stopChild(server);
    log.end();
  }
}
main().catch(error => { console.error(error.stack || error); process.exitCode = 1; });