import fs from "node:fs";
import path from "node:path";
import { fileURLToPath } from "node:url";

type ExtensionContext = {
  hasUI?: boolean;
  ui?: {
    confirm?: (title: string, message: string, options?: Record<string, unknown>) => Promise<boolean>;
  };
};

type ExtensionAPI = {
  registerTool: (spec: Record<string, unknown>) => void;
  on?: (
    eventName: string,
    handler: (event: Record<string, unknown>) => Record<string, unknown> | void,
  ) => void;
};

type MnoteToolManifestEntry = {
  piName: string;
  mnoteName: string;
  label: string;
  description: string;
};

const DEFAULT_TOOLS: MnoteToolManifestEntry[] = [
  {
    piName: "mnote_current_page_read",
    mnoteName: "mnote.current_page.read",
    label: "MNote current page read",
    description: "Read the current MNote page through MNote access scope.",
  },
  {
    piName: "mnote_selection_read",
    mnoteName: "mnote.selection.read",
    label: "MNote selection read",
    description: "Read the current MNote editor selection snapshot supplied by MNote.",
  },
  {
    piName: "mnote_allowed_roots_describe",
    mnoteName: "mnote.allowed_roots.describe",
    label: "MNote allowed roots describe",
    description: "Describe MNote allowed roots and disabled raw tools.",
  },
  {
    piName: "mnote_local_file_read",
    mnoteName: "mnote.local_file.read",
    label: "MNote local file read",
    description: "Read a file only through MNote allowed roots.",
  },
  {
    piName: "mnote_local_file_patch",
    mnoteName: "mnote.local_file.patch",
    label: "MNote local file patch",
    description: "Patch a file only through MNote allowed roots and watcher refresh.",
  },
  {
    piName: "mnote_knowledge_rag_status",
    mnoteName: "mnote.knowledge_rag.status",
    label: "MNote LightRAG status",
    description: "Check the MNote LightRAG knowledge provider status, indexed source registry, dashboard URL, and sync state. Use before knowledge-base questions when availability is uncertain. Params: optional workspaceId/rootUri; MNote fills the current Pi session context when omitted.",
  },
  {
    piName: "mnote_knowledge_rag_query",
    mnoteName: "mnote.knowledge_rag.query",
    label: "MNote LightRAG query",
    description: "Ask the MNote LightRAG knowledge library across indexed books, papers, Office files, PDFs, images, and attachments. Use this for knowledge-base questions and answers that require sources, citations, or evidence. For book or long-document questions, pass query, mode='naive' or 'mix', topK, chunkTopK, includeChunkContent=true, and includeDocumentStructureIndex=true. Use returned references/citations quotes as evidence; do not invent page numbers or hand-write /documents/mnote:// links.",
  },
  {
    piName: "mnote_knowledge_rag_section_context",
    mnoteName: "mnote.knowledge_rag.section_context",
    label: "MNote LightRAG section context",
    description: "Read bounded section blocks/chunks from a LightRAG sidecar using documentStructureIndex ranges returned by mnote_knowledge_rag_query. Use this for second-pass reading of large books or long documents when query references are not enough. Params include sourcePath/sourceId/lightRagDocId/filePath/sectionId, block or paragraph ordinal range, contextBefore/contextAfter, maxBlocks, maxChars.",
  },
  {
    piName: "mnote_knowledge_rag_open_reference",
    mnoteName: "mnote.knowledge_rag.open_reference",
    label: "MNote LightRAG open reference",
    description: "Convert a LightRAG reference, filePath, or chunkId returned by mnote_knowledge_rag_query into a MNote clickable local resource locator. Use when the user asks to open or verify a cited source.",
  },
  {
    piName: "mnote_reference_open",
    mnoteName: "mnote.reference.open",
    label: "MNote reference open",
    description: "Legacy alias for opening a citation/reference through MNote mapping. Prefer mnote_knowledge_rag_open_reference for LightRAG references.",
  },
  {
    piName: "mnote_codex_rescue_request",
    mnoteName: "mnote.codex_rescue.request",
    label: "MNote Codex rescue",
    description: "Ask local Codex to rescue hard MNote/Pi problems before escalating to the user. Use when tools, skills, MCP, LightRAG, environment, or local repo behavior looks broken and normal Pi troubleshooting is insufficient. This tool is admin-gated, approval-gated by default, runs codex exec with workspace-write sandbox and a timeout, and returns Codex's final answer plus stdout/stderr snippets. Provide issue, evidence/logs, attempted steps, and desired outcome. Call at most once per unresolved incident; if Codex cannot fix it, summarize the blocker to the user.",
  },
  {
    piName: "mnote_tool_receipt_write",
    mnoteName: "mnote.tool_receipt.write",
    label: "MNote tool receipt write",
    description: "Write a provider-neutral MNote tool receipt.",
  },
];

const EXTENSION_DIR = path.dirname(fileURLToPath(import.meta.url));
const DEFAULT_CONTEXT_FILE = path.join(EXTENSION_DIR, "mnote-context.json");
const EMBEDDED_CONTEXT: Record<string, unknown> | undefined = undefined;
const CONTEXT_FILE = env("PI_MNOTE_CONTEXT_FILE")
  || DEFAULT_CONTEXT_FILE;
const RUNTIME_IMPL = env("PI_MNOTE_RUNTIME_IMPL")
  || env("MNOTE_PI_RUNTIME_IMPL")
  || (CONTEXT_FILE ? "pi-rust" : "");
const HTTP_BRIDGE_AVAILABLE = env("PI_MNOTE_HTTP_BRIDGE_AVAILABLE") === "1";
const TOOL_POLICIES = parseJsonRecord(env("PI_MNOTE_BRIDGE_TOOL_POLICIES") || env("MNOTE_PI_BRIDGE_TOOL_POLICIES"), {});
const TOOLS = normalizeTools(parseJsonUnknown(env("PI_MNOTE_BRIDGE_TOOLS") || env("MNOTE_PI_BRIDGE_TOOLS")) ?? DEFAULT_TOOLS);
const CONTEXT_PREFIX = "[[MNOTE_PI_CONTEXT_V1:";
let liveContext: Record<string, unknown> | undefined;

function env(name: string): string {
  return (process.env[name] || "").trim();
}

function contextFileExists(): boolean {
  return Boolean(CONTEXT_FILE) && fs.existsSync(CONTEXT_FILE);
}

function parseJsonUnknown(raw: string): unknown {
  if (!raw) return undefined;
  try {
    return JSON.parse(raw);
  } catch {
    return undefined;
  }
}

function parseJsonRecord(raw: string, fallback: Record<string, unknown>): Record<string, unknown> {
  const parsed = parseJsonUnknown(raw);
  return parsed && typeof parsed === "object" && !Array.isArray(parsed)
    ? parsed as Record<string, unknown>
    : fallback;
}

function normalizeTools(value: unknown): MnoteToolManifestEntry[] {
  if (!Array.isArray(value)) return DEFAULT_TOOLS;
  const tools = value
    .map((entry) => {
      if (!entry || typeof entry !== "object") return undefined;
      const record = entry as Record<string, unknown>;
      const piName = stringField(record, "piName") || stringField(record, "pi_name");
      const mnoteName = stringField(record, "mnoteName") || stringField(record, "mnote_name");
      const label = stringField(record, "label") || piName;
      const description = stringField(record, "description") || label;
      if (!piName || !mnoteName) return undefined;
      return { piName, mnoteName, label, description };
    })
    .filter((entry): entry is MnoteToolManifestEntry => Boolean(entry));
  return tools.length ? tools : DEFAULT_TOOLS;
}

function stringField(record: Record<string, unknown>, key: string): string {
  const value = record[key];
  return typeof value === "string" ? value.trim() : "";
}

function recordField(record: Record<string, unknown> | undefined, key: string): Record<string, unknown> | undefined {
  if (!record) return undefined;
  const value = record[key];
  return value && typeof value === "object" && !Array.isArray(value)
    ? value as Record<string, unknown>
    : undefined;
}

function selectedContextPart(context: Record<string, unknown>, key: string): Record<string, unknown> | undefined {
  return recordField(recordField(context, "selectedContext"), key);
}

function contextRefs(context: Record<string, unknown>): string[] {
  const refs = context.contextRefs;
  return Array.isArray(refs) ? refs.filter((ref): ref is string => typeof ref === "string") : [];
}

function toolResult(payload: Record<string, unknown>, isError = false) {
  return {
    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
    details: payload,
    isError,
  };
}

function decodeHexJson(value: string): Record<string, unknown> {
  if (!value || value.length % 2 !== 0 || !/^[0-9a-f]+$/i.test(value)) {
    throw new Error("MNote Pi context hex 无效");
  }
  let jsonText = "";
  for (let index = 0; index < value.length; index += 2) {
    jsonText += String.fromCharCode(Number.parseInt(value.slice(index, index + 2), 16));
  }
  const parsed = JSON.parse(decodeURIComponent(escape(jsonText)));
  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
    throw new Error("MNote Pi context payload 格式无效");
  }
  return parsed as Record<string, unknown>;
}

function captureInputContext(event: Record<string, unknown>) {
  const text = typeof event.text === "string" ? event.text : "";
  const start = text.indexOf(CONTEXT_PREFIX);
  if (start < 0) return { action: "continue" };
  const end = text.indexOf("]]\n", start);
  if (end < 0) return { action: "continue" };
  const encoded = text.slice(start + CONTEXT_PREFIX.length, end);
  try {
    liveContext = decodeHexJson(encoded);
  } catch (error) {
    liveContext = {
      contextError: error instanceof Error ? error.message : String(error),
    };
  }
  return {
    action: "transform",
    text: `${text.slice(0, start)}${text.slice(end + 3)}`,
    images: event.images,
  };
}

function readContextFileSnapshot(): Record<string, unknown> {
  if (!contextFileExists()) {
    throw new Error("MNote Pi 上下文快照不可用；Pi Rust bridge 需要 input hook、embedded context 或 context file");
  }
  const raw = fs.readFileSync(CONTEXT_FILE, "utf8");
  const parsed = JSON.parse(raw);
  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
    throw new Error("MNote Pi 上下文文件格式无效");
  }
  return parsed as Record<string, unknown>;
}

function embeddedContextSnapshot(): Record<string, unknown> | undefined {
  return EMBEDDED_CONTEXT && typeof EMBEDDED_CONTEXT === "object" && !Array.isArray(EMBEDDED_CONTEXT)
    ? EMBEDDED_CONTEXT
    : undefined;
}

function activeContextSnapshot(): Record<string, unknown> | undefined {
  try {
    if (contextFileExists()) return readContextFileSnapshot();
  } catch {
    // Fall back to the input-hook snapshot when the host cannot read files.
  }
  return liveContext || embeddedContextSnapshot();
}

function readContextSnapshot(): Record<string, unknown> {
  const snapshot = activeContextSnapshot();
  if (snapshot) return snapshot;
  return readContextFileSnapshot();
}

function bridgeToken(): string {
  const fromEnv = env("PI_MNOTE_BRIDGE_TOKEN")
    || env("MNOTE_PI_BRIDGE_TOKEN")
    || env("MNOTE_PI_LAB_BRIDGE_TOKEN");
  if (fromEnv) return fromEnv;
  const fromContext = activeContextSnapshot();
  if (fromContext) {
    const value = stringField(fromContext, "bridgeToken");
    if (value) return value;
  }
  return "";
}

function bridgeBaseUrl(): string {
  const fromEnv = env("PI_MNOTE_BRIDGE_BASE_URL")
    || env("MNOTE_PI_BRIDGE_BASE_URL")
    || env("MNOTE_PI_LAB_BASE_URL");
  if (fromEnv) return fromEnv;
  const fromContext = activeContextSnapshot();
  if (fromContext) {
    const value = stringField(fromContext, "bridgeBaseUrl");
    if (value) return value;
  }
  return "http://127.0.0.1:3000";
}

function bridgeSessionId(): string {
  const fromContext = activeContextSnapshot();
  const fromContextSession = fromContext ? stringField(fromContext, "sessionId") : "";
  if (fromContextSession) return fromContextSession;
  const fromEnv = env("PI_MNOTE_BRIDGE_SESSION_ID")
    || env("MNOTE_PI_BRIDGE_SESSION_ID");
  if (fromEnv) return fromEnv;
  return "";
}

function contextAllowedRoots(context: Record<string, unknown>): Record<string, unknown>[] {
  const snapshot = context.allowedRoots;
  if (!snapshot || typeof snapshot !== "object" || Array.isArray(snapshot)) return [];
  const roots = (snapshot as Record<string, unknown>).roots;
  if (!Array.isArray(roots)) return [];
  return roots.filter((root): root is Record<string, unknown> => (
    Boolean(root) && typeof root === "object" && !Array.isArray(root)
  ));
}

function pathIsInside(target: string, root: string): boolean {
  const relative = path.relative(root, target);
  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
}

function resolveAllowedTarget(
  context: Record<string, unknown>,
  rootUri: string,
  relativePath: string,
  options?: { allowMissing?: boolean },
): { target: string; readPath: string } {
  const roots = contextAllowedRoots(context);
  const matchedRoot = roots.find((root) => stringField(root, "rootUri") === rootUri);
  const rootPath = matchedRoot
    ? stringField(matchedRoot, "rootPath")
    : stringField(context, "primaryRootPath") || process.cwd();
  if (!rootPath) throw new Error("MNote allowed root 缺少 rootPath");

  const canonicalRoot = fs.realpathSync(rootPath);
  const requestedTarget = path.isAbsolute(relativePath)
    ? path.resolve(relativePath)
    : path.resolve(canonicalRoot, relativePath);
  const canonicalTarget = options?.allowMissing
    ? canonicalOrParent(requestedTarget)
    : fs.realpathSync(requestedTarget);
  const allowedRoots = roots
    .map((root) => stringField(root, "rootPath"))
    .filter(Boolean)
    .map((root) => fs.realpathSync(root));
  const candidates = allowedRoots.length ? allowedRoots : [canonicalRoot];
  if (!candidates.some((root) => pathIsInside(canonicalTarget, root))) {
    throw new Error(`路径超出 MNote allowed roots: ${relativePath}`);
  }
  const processRoot = fs.realpathSync(process.cwd());
  const readPath = pathIsInside(canonicalTarget, processRoot)
    ? path.relative(processRoot, canonicalTarget) || "."
    : canonicalTarget;
  return { target: canonicalTarget, readPath };
}

function canonicalOrParent(target: string): string {
  try {
    return fs.realpathSync(target);
  } catch {
    const parent = path.dirname(target);
    try {
      return path.join(fs.realpathSync(parent), path.basename(target));
    } catch {
      return path.resolve(target);
    }
  }
}

function sessionRootUri(context: Record<string, unknown>, input: Record<string, unknown>): string {
  return stringField(input, "rootUri")
    || stringField(input, "root_uri")
    || stringField(selectedContextPart(context, "currentPage") || {}, "rootUri")
    || stringField(selectedContextPart(context, "currentFolder") || {}, "rootUri")
    || stringField(context, "rootUri");
}

function joinRelativePath(basePath: string, childPath: string): string {
  const normalizedChild = childPath.replace(/\\/g, "/").replace(/^\/+/, "");
  const normalizedBase = basePath.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
  if (!normalizedBase || path.isAbsolute(childPath)) return normalizedChild;
  if (!normalizedChild || normalizedChild === ".") return normalizedBase;
  if (normalizedChild === normalizedBase || normalizedChild.startsWith(`${normalizedBase}/`)) return normalizedChild;
  return `${normalizedBase}/${normalizedChild}`;
}

function sessionRelativePath(context: Record<string, unknown>, input: Record<string, unknown>, options?: { preferFolder?: boolean }): string {
  const explicitPath = stringField(input, "relativePath")
    || stringField(input, "relative_path")
    || stringField(input, "path");
  const folderPath = stringField(input, "folderPath")
    || stringField(input, "folder_path")
    || stringField(selectedContextPart(context, "currentFolder") || {}, "folderPath");
  if (explicitPath) {
    return options?.preferFolder ? joinRelativePath(folderPath, explicitPath) : explicitPath;
  }
  return stringField(input, "pagePath")
    || stringField(input, "page_path")
    || stringField(selectedContextPart(context, "currentPage") || {}, "pagePath")
    || folderPath
    || stringField(context, "pagePath");
}

function contextualToolParams(toolName: string, params: unknown): Record<string, unknown> {
  const nextParams = { ...((params || {}) as Record<string, unknown>) };
  const context = activeContextSnapshot();
  if (!context) return nextParams;
  const currentPage = selectedContextPart(context, "currentPage");
  const currentFolder = selectedContextPart(context, "currentFolder");
  const selection = selectedContextPart(context, "selection");
  if (!stringField(nextParams, "rootUri")) {
    nextParams.rootUri = stringField(currentPage || {}, "rootUri")
      || stringField(currentFolder || {}, "rootUri")
      || stringField(context, "rootUri")
      || undefined;
  }
  if (!stringField(nextParams, "workspaceId")) {
    nextParams.workspaceId = stringField(currentPage || {}, "workspaceId")
      || stringField(currentFolder || {}, "workspaceId")
      || stringField(context, "workspaceId")
      || undefined;
  }
  if (!stringField(nextParams, "pagePath")) {
    nextParams.pagePath = stringField(currentPage || {}, "pagePath") || undefined;
  }
  if (!stringField(nextParams, "folderPath")) {
    nextParams.folderPath = stringField(currentFolder || {}, "folderPath") || undefined;
  }
  if (toolName === "mnote.selection.read") {
    nextParams.selectionSource = "mnote_sidebar_host";
    nextParams.selection = selection || null;
  }
  return nextParams;
}

function executeNativeCurrentPageRead(params: unknown) {
  try {
    const input = params && typeof params === "object" && !Array.isArray(params)
      ? params as Record<string, unknown>
      : {};
    const context = readContextSnapshot();
    const currentPage = selectedContextPart(context, "currentPage");
    const rootUri = stringField(currentPage || {}, "rootUri")
      || stringField(input, "rootUri")
      || stringField(input, "root_uri");
    const pagePath = stringField(currentPage || {}, "pagePath")
      || stringField(input, "pagePath")
      || stringField(input, "page_path")
      || stringField(input, "path");
    if (!rootUri) throw new Error("读取当前页缺少 rootUri");
    if (!pagePath) throw new Error("读取当前页缺少 pagePath");

    const resolved = resolveAllowedTarget(context, rootUri, pagePath);
    const content = fs.readFileSync(resolved.readPath, "utf8");
    const stat = fs.statSync(resolved.readPath);
    return toolResult({
      ok: true,
      rootUri,
      pagePath,
      path: resolved.target,
      content,
      contentLength: content.length,
      format: "markdown",
      fileVersion: `pi-rust-native-${Math.trunc(stat.mtimeMs)}-${stat.size}`,
      transport: "pi-rust-native-fs",
      contextFile: CONTEXT_FILE,
      contextRefs: contextRefs(context),
      selectedContextCurrentPage: currentPage ?? null,
    });
  } catch (error) {
    return toolResult({
      ok: false,
      code: "mnote_pi_rust_current_page_read_failed",
      message: error instanceof Error ? error.message : String(error),
      transport: "pi-rust-native-fs",
      contextFile: CONTEXT_FILE,
    }, true);
  }
}

function executeNativeLocalFileRead(params: unknown) {
  try {
    const input = params && typeof params === "object" && !Array.isArray(params)
      ? params as Record<string, unknown>
      : {};
    const context = readContextSnapshot();
    const rootUri = sessionRootUri(context, input);
    const relativePath = sessionRelativePath(context, input, { preferFolder: true });
    if (!rootUri) throw new Error("读取文件缺少 rootUri");
    if (!relativePath) throw new Error("读取文件缺少 relativePath/path");
    const resolved = resolveAllowedTarget(context, rootUri, relativePath);
    const content = fs.readFileSync(resolved.readPath, "utf8");
    const stat = fs.statSync(resolved.readPath);
    return toolResult({
      ok: true,
      rootUri,
      relativePath,
      path: resolved.target,
      content,
      contentLength: content.length,
      fileVersion: `pi-rust-native-${Math.trunc(stat.mtimeMs)}-${stat.size}`,
      transport: "pi-rust-native-fs",
      contextFile: CONTEXT_FILE,
    });
  } catch (error) {
    return toolResult({
      ok: false,
      code: "mnote_pi_rust_local_file_read_failed",
      message: error instanceof Error ? error.message : String(error),
      transport: "pi-rust-native-fs",
      contextFile: CONTEXT_FILE,
    }, true);
  }
}

function applyTextOperations(current: string, operations: unknown): string {
  if (!Array.isArray(operations)) throw new Error("operations 必须是数组");
  let next = current;
  for (const operation of operations) {
    if (!operation || typeof operation !== "object" || Array.isArray(operation)) {
      throw new Error("operation 格式无效");
    }
    const op = operation as Record<string, unknown>;
    const type = stringField(op, "type") || stringField(op, "op");
    if (type === "replace") {
      const oldText = typeof op.oldText === "string" ? op.oldText : typeof op.old_text === "string" ? op.old_text : "";
      const newText = typeof op.newText === "string" ? op.newText : typeof op.new_text === "string" ? op.new_text : "";
      if (!oldText) throw new Error("replace operation 缺少 oldText");
      const index = next.indexOf(oldText);
      if (index < 0) throw new Error("replace operation 未找到 oldText");
      next = next.slice(0, index) + newText + next.slice(index + oldText.length);
    } else if (type === "append") {
      const text = typeof op.text === "string" ? op.text : "";
      next += text;
    } else {
      throw new Error(`不支持的 operation: ${type || "unknown"}`);
    }
  }
  return next;
}

function executeNativeLocalFilePatch(params: unknown) {
  try {
    const input = params && typeof params === "object" && !Array.isArray(params)
      ? params as Record<string, unknown>
      : {};
    const context = readContextSnapshot();
    const rootUri = sessionRootUri(context, input);
    const relativePath = sessionRelativePath(context, input, { preferFolder: true });
    if (!rootUri) throw new Error("写入文件缺少 rootUri");
    if (!relativePath) throw new Error("写入文件缺少 relativePath/path");
    const resolved = resolveAllowedTarget(context, rootUri, relativePath, { allowMissing: true });
    const before = fs.existsSync(resolved.target) ? fs.readFileSync(resolved.target, "utf8") : "";
    const next = typeof input.content === "string"
      ? input.content
      : applyTextOperations(before, input.operations);
    fs.mkdirSync(path.dirname(resolved.target), { recursive: true });
    fs.writeFileSync(resolved.target, next, "utf8");
    const stat = fs.statSync(resolved.target);
    return toolResult({
      ok: true,
      rootUri,
      relativePath,
      path: resolved.target,
      beforeFileVersion: `pi-rust-native-before-${before.length}`,
      afterFileVersion: `pi-rust-native-${Math.trunc(stat.mtimeMs)}-${stat.size}`,
      oldSize: before.length,
      newSize: next.length,
      diffSummary: before === next ? "no_changes" : `bytes_delta=${next.length - before.length}`,
      refresh: "mnote local-folder watcher / document-session external refresh",
      transport: "pi-rust-native-fs",
      contextFile: CONTEXT_FILE,
    });
  } catch (error) {
    return toolResult({
      ok: false,
      code: "mnote_pi_rust_local_file_patch_failed",
      message: error instanceof Error ? error.message : String(error),
      transport: "pi-rust-native-fs",
      contextFile: CONTEXT_FILE,
    }, true);
  }
}

function executeNativeSelectionRead() {
  try {
    const context = readContextSnapshot();
    const selection = selectedContextPart(context, "selection");
    return toolResult({
      ok: true,
      selection: selection ?? null,
      text: stringField(selection || {}, "text"),
      selectionSource: "mnote_sidebar_host_snapshot",
      rootUri: context.rootUri ?? null,
      pagePath: context.pagePath ?? null,
      contextRefs: context.contextRefs ?? [],
      transport: "pi-rust-native-context-file",
    });
  } catch (error) {
    return toolResult({
      ok: false,
      code: "mnote_pi_rust_selection_read_failed",
      message: error instanceof Error ? error.message : String(error),
      transport: "pi-rust-native-context-file",
    }, true);
  }
}

function executeNativeAllowedRootsDescribe() {
  try {
    const context = readContextSnapshot();
    return toolResult({
      ok: true,
      allowedRoots: context.allowedRoots ?? { roots: [] },
      rootUri: context.rootUri ?? null,
      pagePath: context.pagePath ?? null,
      workspaceId: context.workspaceId ?? null,
      contextRefs: context.contextRefs ?? [],
      selectedContext: context.selectedContext ?? null,
      primaryRootPath: context.primaryRootPath ?? process.cwd(),
      transport: "pi-rust-native-context-file",
    });
  } catch (error) {
    return toolResult({
      ok: false,
      code: "mnote_pi_rust_allowed_roots_read_failed",
      message: error instanceof Error ? error.message : String(error),
      transport: "pi-rust-native-context-file",
    }, true);
  }
}

function isPiRustNativeRuntime(): boolean {
  return runtimeImplementation() === "pi-rust" || Boolean(CONTEXT_FILE);
}

function executeNativeTool(tool: MnoteToolManifestEntry, params: unknown) {
  if (!isPiRustNativeRuntime() || toolPolicy(tool.mnoteName) !== "allow") return undefined;
  if (tool.mnoteName === "mnote.current_page.read") return executeNativeCurrentPageRead(params);
  if (tool.mnoteName === "mnote.selection.read") return executeNativeSelectionRead();
  if (tool.mnoteName === "mnote.allowed_roots.describe") return executeNativeAllowedRootsDescribe();
  if (tool.mnoteName === "mnote.local_file.read") return executeNativeLocalFileRead(params);
  if (tool.mnoteName === "mnote.local_file.patch") return executeNativeLocalFilePatch(params);
  return undefined;
}

async function callMnote(toolName: string, params: unknown) {
  const sessionId = bridgeSessionId();
  if (!sessionId) {
    return toolResult({
      ok: false,
      code: "mnote_pi_bridge_session_id_missing",
      message: "MNote Pi bridge 缺少有效的 pi_lab sessionId；已忽略 Pi runtime provider session id。",
      toolName,
      transport: "mnote-bridge-http",
    }, true);
  }
  const response = await fetch(`${bridgeBaseUrl()}/api/page-ai/pi/tool-call-bridge`, {
    method: "POST",
    headers: {
      "content-type": "application/json",
      "x-mnote-pi-lab-bridge-token": bridgeToken(),
    },
    body: JSON.stringify({ sessionId, toolName, params: params || {} }),
  });
  const payload = await response.json().catch(() => ({ ok: false, code: "bad_json" }));
  const result = (payload as Record<string, unknown>).result || payload;
  const text = JSON.stringify(modelSafeBridgeResult(toolName, result), null, 2);
  return {
    content: [{ type: "text", text }],
    details: payload,
  };
}

function modelSafeBridgeResult(toolName: string, value: unknown): unknown {
  if (toolName !== "mnote.knowledge_rag.query" || !value || typeof value !== "object" || Array.isArray(value)) {
    return value;
  }
  const result = { ...(value as Record<string, unknown>) };
  delete result.uiCitations;
  delete result.citationMarkdowns;
  delete result.citationRendering;
  result.uiCitationCount = Array.isArray((value as Record<string, unknown>).uiCitations)
    ? ((value as Record<string, unknown>).uiCitations as unknown[]).length
    : 0;
  result.uiCitationDelivery = "Clickable citations are retained in tool details for the MNote UI and omitted from model context.";
  return result;
}

function stableJson(value: unknown): string {
  if (value === null || typeof value !== "object") return JSON.stringify(value);
  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
  const record = value as Record<string, unknown>;
  return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableJson(record[key])}`).join(",")}}`;
}

function stableHash(value: string): string {
  let hash = 5381 >>> 0;
  for (let index = 0; index < value.length; index += 1) {
    hash = (((hash << 5) + hash) + value.charCodeAt(index)) >>> 0;
  }
  return hash.toString(16);
}

function paramsHash(params: unknown): string {
  const copy = { ...((params || {}) as Record<string, unknown>) };
  delete copy.mnoteApproval;
  delete copy.mnote_approval;
  return stableHash(stableJson(copy));
}

function toolPolicy(toolName: string): string {
  const contextPolicies = activeContextSnapshot()?.toolPolicies;
  let contextValue = contextPolicies && typeof contextPolicies === "object" && !Array.isArray(contextPolicies)
    ? (contextPolicies as Record<string, unknown>)[toolName]
    : undefined;
  const value = contextValue ?? TOOL_POLICIES[toolName];
  return typeof value === "string" && value.trim() ? value.trim() : "allow";
}

function runtimeImplementation(): string {
  const fromContext = activeContextSnapshot();
  return fromContext ? stringField(fromContext, "runtimeImplementation") || RUNTIME_IMPL : RUNTIME_IMPL;
}

async function requestMnoteApprovalViaBridge(request: Record<string, unknown>): Promise<Record<string, unknown>> {
  const sessionId = bridgeSessionId();
  if (!sessionId) {
    return {
      ok: false,
      cancelled: true,
      code: "mnote_pi_bridge_session_id_missing",
      message: "MNote Pi bridge 缺少有效的 pi_lab sessionId",
    };
  }
  const response = await fetch(`${bridgeBaseUrl()}/api/page-ai/pi/ui-request-bridge`, {
    method: "POST",
    headers: {
      "content-type": "application/json",
      "x-mnote-pi-lab-bridge-token": bridgeToken(),
    },
    body: JSON.stringify({ sessionId, ...request }),
  });
  return await response.json().catch(() => ({ ok: false, cancelled: true, code: "bad_json" }));
}

async function requestMnoteApproval(
  ctx: ExtensionContext | undefined,
  toolCallId: string,
  toolName: string,
  label: string,
  params: unknown,
): Promise<null | Record<string, unknown>> {
  if (toolPolicy(toolName) !== "ask") return null;
  const approvalId = toolCallId || `approval_${Date.now()}_${Math.random().toString(16).slice(2)}`;
  const approval = { approvalId, toolName, paramsHash: paramsHash(params) };
  const summary = JSON.stringify(params || {}, null, 2).slice(0, 1200);
  const message = `${label}\n${toolName}\n\n${summary}`;

  if (ctx?.hasUI && ctx.ui && typeof ctx.ui.confirm === "function") {
    const result = await ctx.ui.confirm("审批 Pi 工具调用", message, { timeout: 60000 });
    if (result === true) return approval;
    return { ...approval, denied: true };
  }

  const result = await requestMnoteApprovalViaBridge({
    id: approvalId,
    method: "confirm",
    title: "审批 Pi 工具调用",
    message,
    timeoutMs: 60000,
    mnoteApproval: approval,
  });
  if (result && result.confirmed === true) return approval;
  return { ...approval, denied: true };
}

function register(pi: ExtensionAPI, tool: MnoteToolManifestEntry) {
  pi.registerTool({
    name: tool.piName,
    label: tool.label,
    description: tool.description,
    promptSnippet: `${tool.label}: ${tool.description}`,
    parameters: { type: "object", additionalProperties: true },
    execute(toolCallId: unknown, params: unknown, _signal: unknown, _onUpdate: unknown, ctx: ExtensionContext | undefined) {
      if (toolPolicy(tool.mnoteName) === "deny") {
        return toolResult({
          ok: false,
          code: "mnote_tool_denied_by_permission_mode",
          message: `当前 Pi 模式禁止调用工具 ${tool.mnoteName}`,
          toolName: tool.mnoteName,
        }, true);
      }
      const nativeResult = executeNativeTool(tool, params);
      if (nativeResult) return nativeResult;
      if (runtimeImplementation() === "pi-rust" && !HTTP_BRIDGE_AVAILABLE && !bridgeToken()) {
        return toolResult({
          ok: false,
          code: "mnote_pi_rust_service_bridge_unavailable",
          message: `${tool.mnoteName} 缺少 MNote Pi bridge token；Pi Rust 当前应通过原生文件工具或 MNote 受控 bridge 调用。`,
          toolName: tool.mnoteName,
          runtimeImplementation: runtimeImplementation(),
        }, true);
      }
      return executeBridgeTool(toolCallId, params, ctx, tool);
    },
  });
}

async function executeBridgeTool(
  toolCallId: unknown,
  params: unknown,
  ctx: ExtensionContext | undefined,
  tool: MnoteToolManifestEntry,
) {
      const nextParams = contextualToolParams(tool.mnoteName, params);
      const approval = await requestMnoteApproval(ctx, String(toolCallId || ""), tool.mnoteName, tool.label, nextParams);
      if (approval && approval.denied) {
        return {
          content: [{ type: "text", text: JSON.stringify({ ok: false, code: "mnote_tool_approval_cancelled", message: "用户拒绝或未完成 MNote 工具审批", toolName: tool.mnoteName }, null, 2) }],
          details: { ok: false, code: "mnote_tool_approval_cancelled", toolName: tool.mnoteName },
        };
      }
      if (toolPolicy(tool.mnoteName) === "ask") {
        nextParams.mnoteApproval = {
          ...approval,
          confirmed: true,
          method: "extension_ui_confirm",
          toolCallId: String(toolCallId || ""),
          toolName: tool.mnoteName,
          approvedAt: new Date().toISOString(),
        };
      }
      return callMnote(tool.mnoteName, nextParams);
}

export default function mnotePi(pi: ExtensionAPI) {
  pi.on?.("input", captureInputContext);
  for (const tool of TOOLS) register(pi, tool);
}