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

const assert = require('assert/strict');
const crypto = require('crypto');
const fs = require('fs');
const net = require('net');
const os = require('os');
const path = require('path');
const { spawn } = require('child_process');

const REPO_DIR = path.resolve(__dirname, '..');
const SERVER_PATH = path.join(REPO_DIR, 'server.js');
const { TOOLS } = require(path.join(REPO_DIR, 'lib', 'ccweb-mcp-server'));

const INTERNAL_MCP_TOKEN = 'ListUserInputsUnitMcp!234';

function mkdirp(dir) {
  fs.mkdirSync(dir, { recursive: true });
}

function sleep(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

function getFreePort() {
  return new Promise((resolve, reject) => {
    const server = net.createServer();
    server.on('error', reject);
    server.listen(0, '127.0.0.1', () => {
      const address = server.address();
      const port = address && typeof address === 'object' ? address.port : null;
      server.close(() => resolve(port));
    });
  });
}

async function waitForPort(port, timeoutMs = 10000) {
  const started = Date.now();
  let lastError = null;
  while (Date.now() - started < timeoutMs) {
    try {
      await new Promise((resolve, reject) => {
        const socket = net.createConnection({ host: '127.0.0.1', port });
        socket.once('connect', () => {
          socket.destroy();
          resolve();
        });
        socket.once('error', reject);
        socket.setTimeout(500, () => {
          socket.destroy();
          reject(new Error('timeout'));
        });
      });
      return;
    } catch (err) {
      lastError = err;
      await sleep(50);
    }
  }
  throw new Error(`Timed out waiting for port ${port}: ${lastError?.message || 'unknown'}`);
}

async function withServer(env, fn) {
  const child = spawn(process.execPath, [SERVER_PATH], {
    cwd: REPO_DIR,
    env: { ...process.env, ...env },
    stdio: ['ignore', 'pipe', 'pipe'],
  });
  let stdout = '';
  let stderr = '';
  child.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
  child.stderr.on('data', (chunk) => { stderr += chunk.toString(); });

  try {
    await waitForPort(env.PORT, 10000);
    await fn({ stdout: () => stdout, stderr: () => stderr });
  } finally {
    if (child.exitCode === null && !child.signalCode) {
      child.kill('SIGTERM');
      await sleep(300);
    }
    if (child.exitCode === null && !child.signalCode) child.kill('SIGKILL');
  }
}

async function postJson(port, pathname, body) {
  const response = await fetch(`http://127.0.0.1:${port}${pathname}`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'X-CC-Web-MCP-Token': INTERNAL_MCP_TOKEN,
    },
    body: JSON.stringify(body),
  });
  let payload = null;
  try {
    payload = await response.json();
  } catch {}
  return { status: response.status, payload };
}

async function mcpJsonRpc(port, sourceSessionId, message) {
  const query = sourceSessionId ? `?sourceSessionId=${encodeURIComponent(sourceSessionId)}` : '';
  return postJson(port, `/api/internal/mcp/stream${query}`, message);
}

async function callSharedTool(port, sourceSessionId, args = {}) {
  const response = await mcpJsonRpc(port, sourceSessionId, {
    jsonrpc: '2.0',
    id: crypto.randomUUID(),
    method: 'tools/call',
    params: {
      name: 'ccweb_list_user_inputs',
      arguments: args,
    },
  });
  assert.equal(response.status, 200, `tools/call should return HTTP 200, got ${response.status}`);
  assert.ok(response.payload?.result, 'tools/call should return a JSON-RPC result');
  return response.payload.result.structuredContent;
}

async function directInternalCall(port, sourceSessionId, args = {}) {
  const response = await postJson(port, '/api/internal/mcp', {
    tool: 'ccweb_list_user_inputs',
    args,
    sourceSessionId,
  });
  return response;
}

function writeSession(sessionsDir, session) {
  const filePath = path.join(sessionsDir, `${session.id}.json`);
  fs.writeFileSync(filePath, JSON.stringify(session, null, 2));
  return filePath;
}

function sha256(filePath) {
  return crypto.createHash('sha256').update(fs.readFileSync(filePath)).digest('hex');
}

function userMessage(id, content) {
  return {
    id,
    role: 'user',
    content,
    timestamp: `2026-08-17T00:${String(Number(id.replace(/\D/g, '')) || 0).padStart(2, '0')}:00.000Z`,
  };
}

function createFixtures(sessionsDir) {
  const sourceMessages = [];
  for (let index = 1; index <= 18; index += 1) {
    sourceMessages.push(userMessage(`u${String(index).padStart(2, '0')}`, `用户输入 ${String(index).padStart(2, '0')}`));
  }
  sourceMessages.splice(4, 0,
    { id: 'assistant-guidance', role: 'assistant', content: 'assistant 说明不应进入结果', timestamp: '2026-08-17T00:04:10.000Z' },
    { id: 'tool-result', role: 'tool', content: '工具输出不应进入结果', timestamp: '2026-08-17T00:04:20.000Z' },
    { id: 'blank-user', role: 'user', content: '   \n\t', timestamp: '2026-08-17T00:04:30.000Z' },
    {
      id: 'assistant-prompt-card',
      role: 'assistant',
      content: '',
      timestamp: '2026-08-17T00:04:40.000Z',
      ccwebPrompt: {
        id: 'prompt-1',
        status: 'pending',
        title: '需要确认',
        questions: [{ id: 'q1', title: '方向', question: '选择方向' }],
      },
    },
  );
  sourceMessages.push(userMessage('submitted-form', '表单答案：\n\n表单：需要确认\n\n1. 方向\n答案：继续实现最小方案'));

  const sourcePath = writeSession(sessionsDir, {
    id: 'source-session',
    title: '来源会话',
    agent: 'codexapp',
    created: '2026-08-17T00:00:00.000Z',
    updated: '2026-08-17T00:30:00.000Z',
    hasUnread: false,
    isRunning: false,
    messages: sourceMessages,
  });

  const explicitPath = writeSession(sessionsDir, {
    id: 'explicit-session',
    title: '显式会话',
    agent: 'codexapp',
    created: '2026-08-17T01:00:00.000Z',
    updated: '2026-08-17T01:10:00.000Z',
    hasUnread: true,
    isRunning: false,
    messages: [
      userMessage('explicit-old', '显式旧输入'),
      { id: 'explicit-assistant', role: 'assistant', content: '显式 assistant' },
      userMessage('explicit-new', '显式新输入'),
    ],
  });

  const unicodePath = writeSession(sessionsDir, {
    id: 'unicode-session',
    title: 'Unicode 会话',
    agent: 'codexapp',
    created: '2026-08-17T02:00:00.000Z',
    updated: '2026-08-17T02:10:00.000Z',
    messages: [
      userMessage('unicode-old', 'abcdefghij'),
      userMessage('unicode-mid', '一二三四'),
      userMessage('unicode-latest', '🙂🙂🙂🙂'),
    ],
  });

  const exactSinglePath = writeSession(sessionsDir, {
    id: 'exact-single-session',
    title: '恰好预算单消息',
    agent: 'codexapp',
    messages: [userMessage('exact-single', '🙂甲')],
  });

  const exactMorePath = writeSession(sessionsDir, {
    id: 'exact-more-session',
    title: '恰好预算仍有更早消息',
    agent: 'codexapp',
    messages: [
      userMessage('exact-old', '旧'),
      userMessage('exact-latest', '🙂甲'),
    ],
  });

  const emptyPath = writeSession(sessionsDir, {
    id: 'empty-session',
    title: '无有效用户正文',
    agent: 'codexapp',
    messages: [
      { id: 'empty-assistant', role: 'assistant', content: '仅 assistant' },
      { id: 'empty-user', role: 'user', content: ' \n\t ' },
    ],
  });

  return {
    sourcePath,
    explicitPath,
    unicodePath,
    exactSinglePath,
    exactMorePath,
    emptyPath,
  };
}

function assertToolSchema() {
  const tool = TOOLS.find((item) => item.name === 'ccweb_list_user_inputs');
  assert.ok(tool, '正式 ccweb MCP tools/list 应暴露 ccweb_list_user_inputs');
  assert.equal(tool.description, '该工具返回用户输入的近 N 次对话列表。');

  const schema = tool.inputSchema;
  assert.equal(schema?.type, 'object');
  assert.equal(schema.additionalProperties, false, 'schema additionalProperties 必须为 false');
  assert.ok(!Array.isArray(schema.required) || !schema.required.includes('conversationId'), 'conversationId 必须可选');
  assert.deepEqual(schema.properties?.conversationId?.type, 'string');
  assert.equal(schema.properties?.limit?.type, 'integer');
  assert.equal(schema.properties?.limit?.minimum, 1);
  assert.equal(schema.properties?.limit?.maximum, 50);
  assert.match(schema.properties?.limit?.description || '', /默认\s*15|15/);
  assert.equal(schema.properties?.maxChars?.type, 'integer');
  assert.equal(schema.properties?.maxChars?.minimum, 1);
  assert.equal(schema.properties?.maxChars?.maximum, 1000);
  assert.match(schema.properties?.maxChars?.description || '', /默认\s*1000|1000/);
}

async function assertServerToolList(port) {
  const response = await mcpJsonRpc(port, 'source-session', {
    jsonrpc: '2.0',
    id: 'tools-list',
    method: 'tools/list',
    params: {},
  });
  assert.equal(response.status, 200);
  const toolNames = response.payload?.result?.tools?.map((tool) => tool.name) || [];
  assert.ok(toolNames.includes('ccweb_list_user_inputs'), '内部 JSON-RPC tools/list 应包含 ccweb_list_user_inputs');
}

async function assertDefaultsAndFiltering(port) {
  const payload = await callSharedTool(port, 'source-session', {});
  assert.equal(payload.ok, true);
  assert.equal(payload.conversationId, 'source-session');
  assert.equal(payload.requestedLimit, 15);
  assert.equal(payload.maxChars, 1000);
  assert.equal(payload.returnedCount, 15);
  assert.equal(payload.items.length, 15);
  assert.equal(payload.hasMore, true, '超过默认 limit 的更早用户输入应设置 hasMore=true');
  assert.deepEqual(payload.items.map((item) => item.messageId), [
    'u05', 'u06', 'u07', 'u08', 'u09',
    'u10', 'u11', 'u12', 'u13', 'u14',
    'u15', 'u16', 'u17', 'u18', 'submitted-form',
  ]);
  const allContent = payload.items.map((item) => item.content).join('\n');
  assert.match(allContent, /表单答案/, '提交后的普通 user 消息应进入结果');
  assert.doesNotMatch(allContent, /assistant 说明|工具输出/, 'assistant/tool 独有内容不应进入结果');
  assert.ok(
    !payload.items.some((item) => item.messageId === 'assistant-prompt-card'),
    '未提交的 assistant 引导卡不应以 messageId 进入结果'
  );
  assert.ok(payload.totalChars <= 1000);
  for (const item of payload.items) {
    assert.equal(item.contentChars, Array.from(item.content).length);
    assert.equal(item.truncated, false);
  }
}

async function assertExplicitConversation(port) {
  const payload = await callSharedTool(port, 'source-session', { conversationId: 'explicit-session', limit: 10 });
  assert.equal(payload.ok, true);
  assert.equal(payload.conversationId, 'explicit-session');
  assert.deepEqual(payload.items.map((item) => item.content), ['显式旧输入', '显式新输入']);
}

async function assertUnicodeBudgetAndTruncation(port) {
  const payload = await callSharedTool(port, 'source-session', {
    conversationId: 'unicode-session',
    limit: 3,
    maxChars: 6,
  });
  assert.equal(payload.ok, true);
  assert.equal(payload.totalChars, 6);
  assert.equal(payload.returnedCount, 2);
  assert.equal(payload.hasMore, true);
  assert.deepEqual(payload.items.map((item) => item.messageId), ['unicode-mid', 'unicode-latest']);
  assert.equal(payload.items[0].content, '一二');
  assert.equal(payload.items[0].contentChars, 2);
  assert.equal(payload.items[0].originalChars, 4);
  assert.equal(payload.items[0].truncated, true);
  assert.equal(payload.items[1].content, '🙂🙂🙂🙂');
  assert.equal(payload.items[1].contentChars, 4, 'emoji 应按 Unicode code point 计数，而不是 UTF-16 code unit');
  assert.equal(payload.items[1].originalChars, 4);
  assert.equal(payload.items[1].truncated, false);
  assert.ok(payload.items.reduce((sum, item) => sum + item.contentChars, 0) <= 6);
}

async function assertExactBudgetEmptyAndClamps(port) {
  const exactSingle = await callSharedTool(port, 'source-session', {
    conversationId: 'exact-single-session',
    maxChars: 2,
  });
  assert.equal(exactSingle.totalChars, 2);
  assert.equal(exactSingle.hasMore, false, '恰好用满预算且无更早输入时不应误报 hasMore');
  assert.equal(exactSingle.items[0].truncated, false);

  const exactMore = await callSharedTool(port, 'source-session', {
    conversationId: 'exact-more-session',
    maxChars: 2,
  });
  assert.equal(exactMore.totalChars, 2);
  assert.equal(exactMore.returnedCount, 1);
  assert.equal(exactMore.items[0].messageId, 'exact-latest');
  assert.equal(exactMore.items[0].truncated, false);
  assert.equal(exactMore.hasMore, true, '恰好用满预算但仍有更早输入时应标记 hasMore');

  const empty = await callSharedTool(port, 'source-session', { conversationId: 'empty-session' });
  assert.equal(empty.returnedCount, 0);
  assert.equal(empty.totalChars, 0);
  assert.equal(empty.hasMore, false);
  assert.deepEqual(empty.items, []);

  const clamped = await callSharedTool(port, 'source-session', {
    conversationId: 'explicit-session',
    limit: 999,
    maxChars: 9999,
  });
  assert.equal(clamped.requestedLimit, 50);
  assert.equal(clamped.maxChars, 1000);
}

async function assertErrors(port) {
  const missing = await callSharedTool(port, '', {});
  assert.equal(missing.ok, false);
  assert.equal(missing.code, 'missing_source_conversation');

  const invalid = await callSharedTool(port, 'source-session', { conversationId: '!!!', limit: 5 });
  assert.equal(invalid.ok, false);
  assert.equal(invalid.code, 'invalid_conversation_id');

  const notFound = await callSharedTool(port, 'source-session', { conversationId: 'missing-session', limit: 5 });
  assert.equal(notFound.ok, false);
  assert.equal(notFound.code, 'conversation_not_found');
}

async function assertDirectInternalRoute(port) {
  const response = await directInternalCall(port, 'source-session', { limit: 1 });
  assert.equal(response.status, 200);
  assert.equal(response.payload?.ok, true);
  assert.equal(response.payload?.conversationId, 'source-session');
  assert.equal(response.payload?.returnedCount, 1);
}

async function runTest(name, fn, failures) {
  try {
    await fn();
    console.log(`ok - ${name}`);
  } catch (err) {
    failures.push({ name, err });
    console.error(`not ok - ${name}`);
    console.error(`  ${err.stack || err.message}`);
  }
}

async function main() {
  const failures = [];
  await runTest('正式 MCP schema', assertToolSchema, failures);

  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'ccweb-list-user-inputs-'));
  try {
    const sessionsDir = path.join(tempRoot, 'sessions');
    const configDir = path.join(tempRoot, 'config');
    const logsDir = path.join(tempRoot, 'logs');
    mkdirp(sessionsDir);
    mkdirp(configDir);
    mkdirp(logsDir);
    const fixturePaths = createFixtures(sessionsDir);
    const before = Object.fromEntries(Object.entries(fixturePaths).map(([key, filePath]) => {
      const stat = fs.statSync(filePath);
      return [key, { filePath, hash: sha256(filePath), mtimeMs: stat.mtimeMs }];
    }));

    const port = await getFreePort();
    await withServer({
      PORT: String(port),
      CC_WEB_PASSWORD: 'ListUserInputsUnit!234',
      CC_WEB_INTERNAL_MCP_TOKEN: INTERNAL_MCP_TOKEN,
      CC_WEB_CONFIG_DIR: configDir,
      CC_WEB_SESSIONS_DIR: sessionsDir,
      CC_WEB_LOGS_DIR: logsDir,
      CC_WEB_USAGE_STATISTICS: '0',
    }, async () => {
      await runTest('内部 JSON-RPC tools/list 暴露工具', () => assertServerToolList(port), failures);
      await runTest('默认来源会话、最近 15 条、过滤和旧到新排序', () => assertDefaultsAndFiltering(port), failures);
      await runTest('显式指定 conversationId 查询目标会话', () => assertExplicitConversation(port), failures);
      await runTest('maxChars Unicode code point 预算和截断字段', () => assertUnicodeBudgetAndTruncation(port), failures);
      await runTest('恰好预算、空会话和运行时 clamp 边界', () => assertExactBudgetEmptyAndClamps(port), failures);
      await runTest('错误码 missing_source_conversation / invalid_conversation_id / conversation_not_found', () => assertErrors(port), failures);
      await runTest('旧版内部 /api/internal/mcp 路由分派', () => assertDirectInternalRoute(port), failures);
    });

    await runTest('查询不修改 fixture 会话文件', () => {
      for (const entry of Object.values(before)) {
        const stat = fs.statSync(entry.filePath);
        assert.equal(sha256(entry.filePath), entry.hash, `${path.basename(entry.filePath)} 内容不应变化`);
        assert.equal(stat.mtimeMs, entry.mtimeMs, `${path.basename(entry.filePath)} mtime 不应变化`);
      }
    }, failures);
  } finally {
    try {
      fs.rmSync(tempRoot, { recursive: true, force: true });
    } catch (err) {
      failures.push({ name: '清理临时目录', err });
      console.error('not ok - 清理临时目录');
      console.error(`  ${err.stack || err.message}`);
    }
  }

  if (failures.length > 0) {
    console.error(`\n${failures.length} test(s) failed.`);
    process.exitCode = 1;
    return;
  }
  console.log('\nall ccweb_list_user_inputs focused tests passed');
}

main().catch((err) => {
  console.error(err.stack || err.message);
  process.exit(1);
});