/**
 * MNote MCP Client — 最小 MCP client，仅使用 Node 内置模块
 *
 * 支持协议：
 *   - stdio JSONL (child_process.spawn)
 *   - streamable-http POST (http/https 模块)
 *
 * 请求输入格式 (JSON)：
 *   { "server": "name", "mode": "list|status|call",
 *     "tool": "toolName", "arguments": {} }
 * 默认读取 argv[2] 指向的文件；argv[2] 为 "-" 时从 stdin 读取；
 * argv[2] 为 "--request-json" 时直接读取 argv[3]。
 *
 * 输出：stdout 打印 JSON，stderr 仅用于诊断
 *
 * 限制：不含 OAuth/UI/资源写入
 */

import { spawn } from "node:child_process";
import { request as httpRequest } from "node:http";
import { request as httpsRequest } from "node:https";
import { readFileSync, existsSync } from "node:fs";
import { resolve, dirname } from "node:path";
import { fileURLToPath } from "node:url";

/* ============================================================
 * 常量
 * ============================================================ */
const MCP_VERSION = "2024-11-05";
const CLIENT_NAME = "mnote-mcp-client";
const CLIENT_VERSION = "0.1.0";
const REQUEST_TIMEOUT = 30_000;
const SSE_TIMEOUT = 60_000;

/* ============================================================
 * 工具
 * ============================================================ */
function resolveEnv(value) {
  if (typeof value !== "string") return value;
  return value.replace(/\$\{(\w+)\}/g, (_, key) => process.env[key] ?? "");
}

let _reqId = 0;
function nextId() { return ++_reqId; }

function errorResult(message, details = null) {
  return { ok: false, error: message, details, timestamp: new Date().toISOString() };
}
function okResult(data) {
  return { ok: true, data, timestamp: new Date().toISOString() };
}
function extractResult(resp) {
  if (resp == null) throw new Error("Empty response from server");
  if (resp.error) throw new Error(`JSON-RPC error: ${resp.error.message || JSON.stringify(resp.error)}`);
  if (resp.result !== undefined) return resp.result;
  return resp;
}

/* ============================================================
 * 读取 MCP 配置
 * ============================================================ */
function loadMcpConfig(extDir) {
  const configPath = process.env.MNOTE_MCP_CONFIG_PATH || resolve(extDir, ".pi", "mcp.json");
  if (!existsSync(configPath)) return { servers: {} };
  try {
    const raw = readFileSync(configPath, "utf-8").trim();
    if (!raw) return { servers: {} };
    const parsed = JSON.parse(raw);
    const servers = parsed.mcpServers || parsed.servers || parsed;
    if (typeof servers !== "object" || Array.isArray(servers)) {
      return { servers: {}, _parseError: "Config root must be an object with mcpServers key" };
    }
    return { servers };
  } catch (e) {
    return { servers: {}, _parseError: e.message };
  }
}

/* ============================================================
 * stdio transport
 *   行读取器 + 响应队列，支持 send（等响应）和 sendNotify（不等）
 * ============================================================ */
function createStdioTransport(serverConfig, timeout = REQUEST_TIMEOUT) {
  const cmd = resolveEnv(serverConfig.command);
  if (!cmd) throw new Error("stdio transport requires command");
  const args = (serverConfig.args || []).map(resolveEnv);
  const env = serverConfig.env
    ? { ...process.env, ...Object.fromEntries(
        Object.entries(serverConfig.env).map(([k, v]) => [k, resolveEnv(v)])
      )}
    : process.env;

  return new Promise((resolvePromise, rejectPromise) => {
    const detached = process.platform !== "win32";
    const child = spawn(cmd, args, {
      env,
      stdio: ["pipe", "pipe", "pipe"],
      shell: false,
      detached,
    });

    let buf = "";
    let stderrBuf = "";
    let pending = null; // { resolve, reject, timer }
    let closed = false;

    const startTimer = () => {
      return setTimeout(() => {
        if (pending) {
          const p = pending;
          pending = null;
          p.reject(new Error(`Response timeout after ${timeout}ms`));
          clearTimeout(p.timer);
        }
      }, timeout);
    };

    child.stdout.on("data", (chunk) => {
      buf += chunk.toString();
      if (!pending) return;
      const nl = buf.indexOf("\n");
      if (nl < 0) return;
      const line = buf.slice(0, nl);
      buf = buf.slice(nl + 1);
      const p = pending;
      pending = null;
      clearTimeout(p.timer);
      try { p.resolve(JSON.parse(line)); }
      catch { p.reject(new Error(`Invalid JSON: ${line.slice(0, 200)}`)); }
    });

    child.stderr.on("data", (chunk) => { stderrBuf += chunk.toString(); });

    child.on("error", (err) => {
      if (closed) return;
      closed = true;
      if (pending) { pending.reject(new Error(`Spawn error: ${err.message}`)); clearTimeout(pending.timer); pending = null; }
      rejectPromise(new Error(`Spawn error: ${err.message}`));
    });

    child.on("close", (code) => {
      if (closed) return;
      closed = true;
      if (pending) {
        pending.reject(new Error(`Process exited (${code}) before response: ${stderrBuf.slice(0, 300)}`));
        clearTimeout(pending.timer);
        pending = null;
      }
    });

    const transport = {
      _transport: "stdio",
      _child: child,

      /** 发送并等待响应 */
      async send(msg) {
        if (closed) throw new Error("Transport closed");
        if (pending) throw new Error("Concurrent stdio MCP requests are not supported");
        const line = JSON.stringify(msg) + "\n";
        return new Promise((resolve, reject) => {
          const timer = startTimer();
          const current = { resolve, reject, timer };
          pending = current;
          child.stdin.write(line, (err) => {
            if (!err || pending !== current) return;
            pending = null;
            clearTimeout(timer);
            reject(new Error(`Write error: ${err.message}`));
          });
          // 尝试立即读取（数据可能已在缓冲区）
          if (!pending) return;
          const nl = buf.indexOf("\n");
          if (nl < 0) return;
          const p = pending;
          pending = null;
          clearTimeout(p.timer);
          const line2 = buf.slice(0, nl);
          buf = buf.slice(nl + 1);
          try { p.resolve(JSON.parse(line2)); }
          catch { p.reject(new Error(`Invalid JSON: ${line2.slice(0, 200)}`)); }
        });
      },

      /** 发送通知（不等待响应） */
      async sendNotify(msg) {
        if (closed) return;
        const line = JSON.stringify(msg) + "\n";
        return new Promise((resolve, reject) => {
          child.stdin.write(line, (err) => {
            if (err) reject(new Error(`Write error: ${err.message}`));
            else resolve();
          });
        });
      },

      async close() {
        if (pending) { pending.reject(new Error("Transport closed")); clearTimeout(pending.timer); pending = null; }
        if (closed) return;
        closed = true;
        child.stdin.end();
        const kill = (signal) => {
          try {
            if (detached && child.pid) process.kill(-child.pid, signal);
            else child.kill(signal);
          } catch {}
        };
        kill("SIGTERM");
        await new Promise((resolve) => {
          if (child.exitCode !== null) {
            resolve();
            return;
          }
          const forceTimer = setTimeout(() => {
            kill("SIGKILL");
            resolve();
          }, 1000);
          child.once("close", () => {
            clearTimeout(forceTimer);
            resolve();
          });
        });
      },
    };

    resolvePromise(transport);
  });
}

/* ============================================================
 * HTTP transport
 * ============================================================ */
function createHttpTransport(serverConfig) {
  const urlStr = resolveEnv(serverConfig.url);
  if (!urlStr) throw new Error("HTTP transport requires url");
  const url = new URL(urlStr);
  if (!["http:", "https:"].includes(url.protocol)) {
    throw new Error(`Unsupported HTTP URL scheme: ${url.protocol}`);
  }
  const isHttps = url.protocol === "https:";
  const requester = isHttps ? httpsRequest : httpRequest;
  const configuredHeaders = Object.fromEntries(
    Object.entries(serverConfig.headers || {}).map(([key, value]) => [key, resolveEnv(value)]),
  );
  let sessionId = null;

  function parseSseResponse(raw, requestId) {
    const payloads = [];
    let dataLines = [];
    const flush = () => {
      if (dataLines.length === 0) return;
      const data = dataLines.join("\n");
      dataLines = [];
      try {
        payloads.push(JSON.parse(data));
      } catch {
        payloads.push({ _rawData: data });
      }
    };
    for (const rawLine of raw.split(/\r?\n/)) {
      if (rawLine === "") {
        flush();
        continue;
      }
      if (rawLine.startsWith("data:")) {
        dataLines.push(rawLine.slice(5).trimStart());
      }
    }
    flush();
    return payloads.find((payload) => payload?.id === requestId)
      || payloads.find((payload) => payload?.result !== undefined || payload?.error)
      || payloads.at(-1)
      || { _sseRaw: raw };
  }

  return {
    _transport: "http",
    _url: urlStr,

    async send(msg, t = SSE_TIMEOUT) {
      const body = JSON.stringify(msg);
      return new Promise((resolve, reject) => {
        let settled = false;
        let req;
        const finishResolve = (value) => {
          if (settled) return;
          settled = true;
          clearTimeout(timer);
          resolve(value);
        };
        const finishReject = (error) => {
          if (settled) return;
          settled = true;
          clearTimeout(timer);
          reject(error);
        };
        const timer = setTimeout(() => {
          req?.destroy();
          finishReject(new Error(`HTTP timeout after ${t}ms`));
        }, t);
        const headers = {
          "Content-Type": "application/json",
          "Accept": "application/json, text/event-stream",
          "MCP-Protocol-Version": MCP_VERSION,
          ...configuredHeaders,
        };
        if (sessionId) headers["Mcp-Session-Id"] = sessionId;
        const opts = {
          hostname: url.hostname, port: url.port, path: url.pathname + url.search,
          method: "POST",
          headers,
        };
        req = requester(opts, (res) => {
          sessionId = res.headers["mcp-session-id"] || sessionId;
          const ct = res.headers["content-type"] || "";
          const chunks = [];
          res.on("data", (c) => chunks.push(c));
          res.on("end", () => {
            const raw = Buffer.concat(chunks).toString();
            if ((res.statusCode || 500) >= 400) {
              finishReject(new Error(`HTTP ${res.statusCode}: ${raw.slice(0, 500)}`));
              return;
            }
            if (!raw.trim()) {
              finishResolve({});
              return;
            }
            if (ct.includes("text/event-stream")) {
              finishResolve(parseSseResponse(raw, msg.id));
            } else {
              try { finishResolve(JSON.parse(raw)); }
              catch { finishResolve({ _raw: raw }); }
            }
          });
          res.on("error", (err) => finishReject(new Error(`HTTP response error: ${err.message}`)));
        });
        req.on("error", (err) => finishReject(new Error(`HTTP error: ${err.message}`)));
        req.write(body);
        req.end();
      });
    },

    async sendNotify(msg) {
      await this.send(msg, 5000);
    },

    async close() {},
  };
}

async function createTransport(serverConfig) {
  const transport = String(serverConfig.transport || "").trim().toLowerCase();
  if (serverConfig.url || transport === "streamable-http" || transport === "sse" || transport === "http") {
    return createHttpTransport(serverConfig);
  }
  if (serverConfig.command || transport === "stdio" || !transport) {
    return createStdioTransport(serverConfig);
  }
  throw new Error(`Unsupported MCP transport: ${transport}`);
}

/* ============================================================
 * MCP 会话
 * ============================================================ */
class McpSession {
  constructor(transport, serverName) {
    this.transport = transport;
    this.serverName = serverName;
    this.initialized = false;
    this.serverCapabilities = null;
    this.serverVersion = null;
  }

  async initialize() {
    const initMsg = {
      jsonrpc: "2.0", id: nextId(), method: "initialize",
      params: {
        protocolVersion: MCP_VERSION,
        capabilities: { tools: {} },
        clientInfo: { name: CLIENT_NAME, version: CLIENT_VERSION },
      },
    };
    const resp = await this.transport.send(initMsg, REQUEST_TIMEOUT);
    const result = extractResult(resp);

    if (result.protocolVersion) {
      this.serverCapabilities = result.capabilities || {};
      this.serverVersion = result.serverInfo?.name
        ? `${result.serverInfo.name} ${result.serverInfo.version || ""}`
        : "unknown";
      this.initialized = true;

      // 通知（不等待响应）
      const notif = { jsonrpc: "2.0", method: "notifications/initialized" };
      this.transport.sendNotify(notif).catch(() => {});
    } else {
      throw new Error(`Unexpected initialize result: ${JSON.stringify(result).slice(0, 300)}`);
    }
  }

  async listTools() {
    if (!this.initialized) await this.initialize();
    const msg = { jsonrpc: "2.0", id: nextId(), method: "tools/list", params: {} };
    const resp = await this.transport.send(msg, REQUEST_TIMEOUT);
    const result = extractResult(resp);
    if (result.tools) return result.tools;
    throw new Error(`tools/list missing 'tools': ${JSON.stringify(result).slice(0, 300)}`);
  }

  async callTool(name, args = {}) {
    if (!this.initialized) await this.initialize();
    const msg = {
      jsonrpc: "2.0", id: nextId(), method: "tools/call",
      params: { name, arguments: args },
    };
    const resp = await this.transport.send(msg, REQUEST_TIMEOUT);
    return extractResult(resp);
  }

  async close() { await this.transport.close(); }
}

async function readRequestInput(requestArg, inlineJson) {
  if (requestArg === "--request-json") {
    if (!inlineJson) throw new Error("--request-json 缺少 JSON 参数");
    return inlineJson;
  }
  if (requestArg !== "-") {
    return readFileSync(requestArg, "utf-8");
  }
  const chunks = [];
  for await (const chunk of process.stdin) chunks.push(chunk);
  return Buffer.concat(chunks).toString("utf-8");
}

/* ============================================================
 * 主流程
 * ============================================================ */
async function main() {
  const requestArg = process.argv[2];
  if (!requestArg) {
    console.log(JSON.stringify(errorResult(
      "Usage: node client.mjs <request.json|-> | --request-json '<json>'",
    )));
    process.exit(1);
  }

  let request;
  try { request = JSON.parse(await readRequestInput(requestArg, process.argv[3])); }
  catch (e) { console.log(JSON.stringify(errorResult(`Cannot read request: ${e.message}`))); process.exit(1); }

  const { server: serverName, mode } = request;
  if (!serverName) { console.log(JSON.stringify(errorResult("Missing 'server'"))); process.exit(1); }

  const extDir = dirname(fileURLToPath(import.meta.url));
  const config = loadMcpConfig(extDir);
  const serverConfig = config.servers[serverName];

  if (mode === "status") {
    const result = {
      configured: !!serverConfig, serverName,
      configError: config._parseError || null,
      config: serverConfig ? {
        transport: serverConfig.transport || null,
        command: serverConfig.command || null, url: serverConfig.url || null,
        argsCount: serverConfig.args?.length || 0, hasEnv: !!serverConfig.env, disabled: !!serverConfig.disabled,
      } : null,
      availableServers: Object.keys(config.servers),
    };
    if (serverConfig && !serverConfig.disabled) {
      try {
        const transport = await createTransport(serverConfig);
        const session = new McpSession(transport, serverName);
        await session.initialize();
        result.connected = true;
        result.serverVersion = session.serverVersion;
        result.serverCapabilities = session.serverCapabilities;
        await session.close();
      } catch (e) { result.connected = false; result.connectError = e.message; }
    } else if (serverConfig?.disabled) { result.statusNote = "disabled"; }
    console.log(JSON.stringify(okResult(result)));
    return;
  }

  if (!serverConfig) {
    console.log(JSON.stringify(errorResult(`Server "${serverName}" not found. Available: ${Object.keys(config.servers).join(", ") || "(none)"}`)));
    process.exit(1);
  }
  if (serverConfig.disabled) {
    console.log(JSON.stringify(errorResult(`Server "${serverName}" is disabled`)));
    process.exit(1);
  }

  let transport;
  try { transport = await createTransport(serverConfig); }
  catch (e) { console.log(JSON.stringify(errorResult(`Transport error: ${e.message}`))); process.exit(1); }

  const session = new McpSession(transport, serverName);
  try {
    if (mode === "list") {
      const tools = await session.listTools();
      console.log(JSON.stringify(okResult({ server: serverName, tools, toolCount: tools.length })));
    } else if (mode === "call") {
      const { tool, arguments: args } = request;
      if (!tool) { console.log(JSON.stringify(errorResult("Missing 'tool'"))); process.exit(1); }
      const result = await session.callTool(tool, args || {});
      console.log(JSON.stringify(okResult({ server: serverName, tool, result })));
    } else {
      console.log(JSON.stringify(errorResult(`Unknown mode: ${mode}`)));
      process.exit(1);
    }
  } catch (e) {
    console.log(JSON.stringify(errorResult(`MCP ${mode} error: ${e.message}`)));
  } finally {
    await session.close();
  }
}

main().catch((e) => {
  console.log(JSON.stringify(errorResult(`Fatal: ${e.message}`)));
  process.exit(1);
});