// Setting Spectra up without the command line (spec §5.0). Each step runs

// a spectra command; every confirmation spectra would ask at a terminal is

// a dialog here, after which the command runs with --yes or --expect.

import * as cp from "node:child_process";

import * as fs from "node:fs";

import * as os from "node:os";

import * as path from "node:path";

import * as vscode from "vscode";

import * as cli from "./cli";

import { EXPIRIES, KINDS, expandHome, mergeMcpConfig, nameFromFolder, shimArgs, suggestAgentName, validName } from "./pure";

import type { Agent, Project } from "./spectra-api";

export interface Hooks {

  /** After a step that changes what Spectra is or who signs. */

  changed(): Promise<void>;

  projects(): Project[];

  agents(): Agent[];

  folderProject(): string | undefined;

}

function folder(): vscode.WorkspaceFolder | undefined {

  return vscode.workspace.workspaceFolders?.[0];

}

async function fail(e: unknown): Promise<undefined> {

  void vscode.window.showErrorMessage(`Spectra: ${(e as Error).message}`);

  return undefined;

}

export async function checkBinary(): Promise<boolean> {

  const bin = cli.binary();

  if (bin) {

    const r = await cli.run(["--version"]);

    if (r.code === 0) {

      void vscode.window.showInformationMessage(`Found ${r.stdout.trim()} at ${bin}.`);

      return true;

    }

  }

  const pick = await vscode.window.showWarningMessage(

    "The spectra program was not found. Install it (make install in the spectra repository puts it in ~/.local/bin), or point Spectra at it.",

    "Locate spectra…",

  );

  if (pick) {

    const f = await vscode.window.showOpenDialog({ canSelectMany: false, openLabel: "Use this spectra" });

    if (f?.[0]) {

      await vscode.workspace.getConfiguration("spectra").update("path", f[0].fsPath, vscode.ConfigurationTarget.Global);

      return checkBinary();

    }

  }

  return false;

}

export async function createIdentity(h: Hooks): Promise<void> {

  const st = await cli.status().catch(() => undefined);

  if (st?.identity) {

    void vscode.window.showInformationMessage(`You already have an identity: ${st.identity.name}, key ${st.identity.key.slice(0, 12)}…`);

    return;

  }

  const name = await vscode.window.showInputBox({

    title: "Your identity (1/2)",

    prompt: "Your name, as your agents will see it",

    value: os.userInfo().username,

    validateInput: (v) => (v.trim() ? undefined : "A name, please"),

  });

  if (!name) return;

  const contact = await vscode.window.showInputBox({ title: "Your identity (2/2)", prompt: "An email or URL to show beside it (optional)" });

  if (contact === undefined) return;

  try {

    const made = await cli.json<{ name: string; key: string; home: string }>(["identity", "create", "--name", name.trim(), "--contact", contact.trim(), "--json"]);

    const copy = await vscode.window.showInformationMessage(

      `Created your identity, ${made.name}. Its key is ${made.key.slice(0, 12)}…; the keys folder in ${made.home} is secret: anyone with it can act as you.`,

      "Copy Key",

    );

    if (copy) await vscode.env.clipboard.writeText(made.key);

    await h.changed();

  } catch (e) {

    await fail(e);

  }

}

export async function setupHere(h: Hooks): Promise<void> {

  const ok = await vscode.window.showInformationMessage(

    "Run Spectra on this machine?",

    { modal: true, detail: "This makes its ledger in ~/.local/share/spectra, owned by your identity, and starts it. Agents on this machine connect to it." },

    "Run Here",

  );

  if (!ok) return;

  try {

    const st = await cli.status();

    if (!st.local.initialised) await cli.ok(["init"]);

    if (!(await cli.status()).local.serving) startDaemon();

    await new Promise((r) => setTimeout(r, 1500));

    await h.changed();

  } catch (e) {

    await fail(e);

  }

}

/** The user service if it is installed, else a terminal running spectra serve. */

export function startDaemon(): void {

  const unit = path.join(os.homedir(), ".config", "systemd", "user", "spectra.service");

  if (fs.existsSync(unit)) {

    cp.execFile("systemctl", ["--user", "start", "spectra"], () => undefined);

    return;

  }

  const bin = cli.binary();

  if (!bin) return;

  const t = vscode.window.createTerminal({ name: "Spectra", shellPath: bin, shellArgs: ["serve"], isTransient: false });

  t.show(true);

}

export async function connectServer(h: Hooks): Promise<void> {

  const url = await vscode.window.showInputBox({

    title: "Connect to a server",

    prompt: "The server's address",

    placeHolder: "https://earth.example:7350",

    validateInput: (v) => (/^https:\/\/[^/\s]+/.test(v.trim()) ? undefined : "An https:// address"),

  });

  if (!url) return;

  const st = await cli.status().catch(() => undefined);

  let probe: { name: string; instance: string; owner: string | null; waiting_for: string | null; yours: boolean };

  try {

    probe = await cli.json(["probe", url.trim(), "--json"]);

  } catch (e) {

    const msg = (e as Error).message;

    const copy = await vscode.window.showErrorMessage(

      `Spectra: ${msg}. If the server is not set up yet, run there: spectra init --owner ${st?.identity?.key ?? "YOUR-KEY"}`,

      ...(st?.identity ? ["Copy That Command"] : []),

    );

    if (copy && st?.identity) await vscode.env.clipboard.writeText(`spectra init --owner ${st.identity.key}`);

    return;

  }

  if (!probe.yours) {

    const whose = probe.owner ? "belongs to someone else" : `waits for another identity (${(probe.waiting_for ?? "").slice(0, 12)}…)`;

    const copy = await vscode.window.showErrorMessage(

      `Spectra: ${probe.name} ${whose}. To set it up for you, run there: spectra init --owner ${st?.identity?.key ?? "YOUR-KEY"}`,

      ...(st?.identity ? ["Copy That Command"] : []),

    );

    if (copy && st?.identity) await vscode.env.clipboard.writeText(`spectra init --owner ${st.identity.key}`);

    return;

  }

  const grouped = probe.instance.match(/.{1,4}/g)!.join(" ");

  const trust = await vscode.window.showWarningMessage(

    `Trust ${probe.name} as your Spectra?`,

    {

      modal: true,

      detail: `Its instance key is:\n\n${grouped}\n\nWhen the server was set up, spectra init printed its instance key. Trust it only if this is the same. Your identity will then delegate to it, and this machine will pin its certificate.`,

    },

    "Trust",

  );

  if (!trust) return;

  try {

    await cli.ok(["connect", url.trim(), "--expect", probe.instance]);

    void vscode.window.showInformationMessage(`Connected to ${probe.name}.`);

    await h.changed();

  } catch (e) {

    await fail(e);

  }

}

export async function registerFolder(h: Hooks): Promise<void> {

  const f = folder();

  if (!f) {

    void vscode.window.showWarningMessage("Open a folder first: a project is the work in it.");

    return;

  }

  const already = h.folderProject();

  if (already) {

    void vscode.window.showInformationMessage(`This folder is already the project ${already}.`);

    return;

  }

  const taken = h.projects().map((p) => p.name);

  const name = await vscode.window.showInputBox({

    title: "Register this folder as a project (1/2)",

    prompt: "The project's name; its channel is #name",

    value: nameFromFolder(f.uri.fsPath),

    validateInput: (v) => (!validName(v) ? "Lower-case letters, digits and dashes" : taken.includes(v) ? "Taken" : undefined),

  });

  if (!name) return;

  const description = await vscode.window.showInputBox({ title: "Register this folder as a project (2/2)", prompt: "What the work is, for your agents (optional)" });

  if (description === undefined) return;

  try {

    await cli.ok(["project", "add", f.uri.fsPath, "--name", name, "-d", description]);

    await h.changed();

    const next = await vscode.window.showInformationMessage(`Registered ${name}. Add an agent for this folder now, so its AI client can talk on #${name}?`, "Add an Agent");

    if (next) await addAgent(h);

  } catch (e) {

    await fail(e);

  }

}

export async function linkProject(h: Hooks): Promise<void> {

  const names = h.projects().map((p) => p.name);

  const p = await vscode.window.showQuickPick(names, { title: "Link projects (1/2)", placeHolder: "Which project depends on another?" });

  if (!p) return;

  const q = await vscode.window.showQuickPick(names.filter((n) => n !== p), { title: "Link projects (2/2)", placeHolder: `${p} depends on…` });

  if (!q) return;

  try {

    await cli.ok(["project", "link", p, "--depends-on", q]);

    await h.changed();

  } catch (e) {

    await fail(e);

  }

}

export async function addAgent(h: Hooks): Promise<void> {

  const projects = h.projects().map((p) => p.name);

  if (!projects.length) {

    void vscode.window.showWarningMessage("An agent needs a project: register this folder first.", "Register This Folder").then((x) => {

      if (x) void vscode.commands.executeCommand("spectra.registerFolder");

    });

    return;

  }

  const kind = await vscode.window.showQuickPick(

    KINDS.map((k) => ({ label: k.label, client: k.kind })),

    { title: "Add an agent (1/4)", placeHolder: "Which client will the agent run in?" },

  );

  if (!kind) return;

  const mine = h.folderProject();

  const project =

    projects.length === 1

      ? projects[0]

      : await vscode.window.showQuickPick(

          [...projects].sort((a, b) => Number(b === mine) - Number(a === mine)),

          { title: "Add an agent (2/4)", placeHolder: "Which project will it work on?" },

        );

  if (!project) return;

  const taken = h.agents().map((a) => a.name);

  const name = await vscode.window.showInputBox({

    title: "Add an agent (3/4)",

    prompt: "Its name",

    value: suggestAgentName(kind.client, project, taken),

    validateInput: (v) => (!validName(v) ? "Lower-case letters, digits and dashes" : taken.includes(v) ? "Taken" : undefined),

  });

  if (!name) return;

  const expiry = await vscode.window.showQuickPick(EXPIRIES.map((e) => ({ label: e.label, arg: e.arg })), {

    title: "Add an agent (4/4)",

    placeHolder: "How long may it act for you? (Renew Agent gives it more time later.)",

  });

  if (!expiry) return;

  const home = expandHome(path.join(vscode.workspace.getConfiguration("spectra").get<string>("agentsHome") || "~/.spectra-agents", name), os.homedir());

  const ok = await vscode.window.showWarningMessage(

    `Let ${name} act for you?`,

    { modal: true, detail: `${kind.label} on #${project}, ${expiry.arg ? `for ${expiry.label.toLowerCase()}` : "until you disable it"}. Its key is made in ${home}; your identity will delegate to it.` },

    "Let It Act for Me",

  );

  if (!ok) return;

  try {

    const args = ["agent", "add", name, "--kind", kind.client, "--project", project, "--home", home, "--yes", ...(expiry.arg ? ["--expires", expiry.arg] : [])];

    await cli.ok(args);

    await h.changed();

  } catch (e) {

    await fail(e);

    return;

  }

  await configureClient(kind.client, name, home);

}

/** Write the agent's MCP entry for its client, or say how. */

async function configureClient(kind: string, agent: string, home: string): Promise<void> {

  const bin = cli.binary() ?? "spectra";

  const args = shimArgs(agent, home);

  const line = `${bin} ${args.join(" ")}`;

  const which = KINDS.find((k) => k.kind === kind)?.label ?? kind;

  const go = await vscode.window.showInformationMessage(`Added ${agent}. Connect ${which} to Spectra as ${agent}?`, "Connect It", "Show Me How");

  if (go === "Show Me How" || !go) {

    if (go) {

      const doc = await vscode.workspace.openTextDocument({

        language: "markdown",

        content: `# Connecting ${agent}\n\nIn ${which}, add an MCP server named \`spectra\` that runs:\n\n\`\`\`\n${line}\n\`\`\`\n\nClaude Code: \`claude mcp add spectra -- ${line}\` in the project's folder.\nKimi Code: \`kimi mcp add spectra -- ${line}\`.\nAntigravity: in \`~/.gemini/config/mcp_config.json\`, \`mcpServers.spectra = { "command": "${bin}", "args": ${JSON.stringify(args)} }\`.\n`,

      });

      await vscode.window.showTextDocument(doc);

    }

    return;

  }

  const cwd = folder()?.uri.fsPath;

  // One entry per client for every folder (spectra mcp --auto): the shim

  // speaks for the agent of whichever folder a session starts in.

  const auto = ["mcp", "--auto", "--kind", kind];

  try {

    if (kind === "claude-code") {

      const tool = cli.program("claude");

      if (!tool) throw new Error("claude was not found on PATH or in ~/.local/bin");

      const list = await new Promise<string>((resolve) => cp.execFile(tool, ["mcp", "get", "spectra"], { cwd }, (_e, out) => resolve(String(out))));

      if (!list.includes("--auto")) {

        await new Promise<void>((resolve) => cp.execFile(tool, ["mcp", "remove", "--scope", "user", "spectra"], () => resolve()));

        await new Promise<void>((resolve, reject) =>

          cp.execFile(tool, ["mcp", "add", "--scope", "user", "spectra", "--", bin, ...auto], (err, _o, stderr) => (err ? reject(new Error(stderr.trim() || err.message)) : resolve())),

        );

      }

      // A per-folder entry would override the shared one: remove it.

      await new Promise<void>((resolve) => cp.execFile(tool, ["mcp", "remove", "--scope", "local", "spectra"], { cwd }, () => resolve()));

      void vscode.window.showInformationMessage(`Claude Code connects to Spectra as ${agent} in this folder. Start a new Claude Code session here to pick it up: one already open does not get it.`);

    } else if (kind === "kimi-code") {

      // Kimi Code reads ~/.kimi-code/mcp.json (or $KIMI_CODE_HOME/mcp.json).

      const dir = process.env.KIMI_CODE_HOME || path.join(os.homedir(), ".kimi-code");

      const file = path.join(dir, "mcp.json");

      const before = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";

      if (before) fs.copyFileSync(file, file + ".bak");

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

      fs.writeFileSync(file, mergeMcpConfig(before, bin, auto));

      void vscode.window.showInformationMessage(`Kimi Code connects to Spectra as ${agent} in this folder (${file}). Start a new Kimi session here to pick it up: one already open does not get it.`);

    } else if (kind === "antigravity") {

      const file = path.join(os.homedir(), ".gemini", "config", "mcp_config.json");

      const before = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";

      if (before) fs.copyFileSync(file, file + ".bak");

      fs.mkdirSync(path.dirname(file), { recursive: true });

      fs.writeFileSync(file, mergeMcpConfig(before, bin, auto));

      void vscode.window.showInformationMessage(`Antigravity connects to Spectra as ${agent} in this folder (${file}${before ? ", previous copy kept as .bak" : ""}): restart it to pick it up.`);

    } else {

      await vscode.env.clipboard.writeText(line);

      void vscode.window.showInformationMessage(`Copied the command for ${which}'s MCP settings: ${line}`);

    }

  } catch (e) {

    const copy = await vscode.window.showErrorMessage(`Could not connect ${which} to Spectra: ${(e as Error).message}. Add an MCP server named spectra in this folder running: ${line}`, "Copy Command");

    if (copy) await vscode.env.clipboard.writeText(kind === "claude-code" ? `claude mcp add spectra -- ${line}` : line);

  }

}

export async function renewAgent(h: Hooks, agent?: string): Promise<void> {

  const name = agent ?? (await vscode.window.showQuickPick(h.agents().filter((a) => !a.disabled).map((a) => a.name), { placeHolder: "Which agent?" }));

  if (!name) return;

  const expiry = await vscode.window.showQuickPick(EXPIRIES.map((e) => ({ label: e.label, arg: e.arg ?? "never" })), { placeHolder: `How long may ${name} act for you from now?` });

  if (!expiry) return;

  try {

    await cli.ok(["agent", "renew", name, "--expires", expiry.arg]);

    await h.changed();

  } catch (e) {

    await fail(e);

  }

}

/** Run `spectra agent allow` for each change; report what failed. */

async function grant(h: Hooks, changes: { agent: string; channel: string; allow: boolean }[]): Promise<void> {

  const failed: string[] = [];

  for (const c of changes) {

    try {

      await cli.ok(["agent", "allow", c.agent, "--channel", c.channel, ...(c.allow ? [] : ["--remove"])]);

    } catch (e) {

      failed.push(`${c.agent} in #${c.channel}: ${(e as Error).message}`);

    }

  }

  await h.changed();

  if (failed.length) void vscode.window.showErrorMessage(`Spectra: not changed: ${failed.join("; ")}`);

  else if (changes.length) void vscode.window.setStatusBarMessage(`$(check) ${changes.length} channel permission${changes.length === 1 ? "" : "s"} signed into Spectra`, 5000);

}

/** Which other projects' channels an agent may post in. */

export async function agentChannels(h: Hooks, agent?: string): Promise<void> {

  const name = agent ?? (await vscode.window.showQuickPick(h.agents().filter((a) => !a.disabled).map((a) => a.name), { placeHolder: "Which agent?" }));

  const a = h.agents().find((x) => x.name === name);

  if (!a) return;

  const now = new Set(a.channels ?? []);

  const items = h

    .projects()

    .filter((p) => p.name !== a.project)

    .map((p) => ({ label: `#${p.name}`, description: p.description || undefined, picked: now.has(p.name), channel: p.name }));

  if (!items.length) {

    void vscode.window.showInformationMessage(`There are no other projects for ${a.name} to post in.`);

    return;

  }

  const picked = await vscode.window.showQuickPick(items, {

    canPickMany: true,

    title: `Channels ${a.name} may post in`,

    placeHolder: `Besides #${a.project} and #general. Untick to take a channel back.`,

  });

  if (!picked) return;

  const want = new Set(picked.map((p) => p.channel));

  const changes = items

    .filter((i) => want.has(i.channel) !== now.has(i.channel))

    .map((i) => ({ agent: a.name, channel: i.channel, allow: want.has(i.channel) }));

  await grant(h, changes);

}

/** Which agents from other projects may post in a project's channel. */

export async function channelAgents(h: Hooks, channel?: string): Promise<void> {

  const name = (channel ?? (await vscode.window.showQuickPick(h.projects().map((p) => p.name), { placeHolder: "Which project's channel?" })))?.replace(/^#/, "");

  if (!name) return;

  const items = h

    .agents()

    .filter((a) => !a.disabled && a.project !== name)

    .map((a) => ({ label: a.name, description: `${a.kind} · #${a.project}`, picked: (a.channels ?? []).includes(name), agent: a.name }));

  if (!items.length) {

    void vscode.window.showInformationMessage(`Every agent already works on ${name}.`);

    return;

  }

  const own = h.agents().filter((a) => !a.disabled && a.project === name).map((a) => a.name);

  const picked = await vscode.window.showQuickPick(items, {

    canPickMany: true,

    title: `Agents who may post in #${name}`,

    placeHolder: `${own.length ? `${own.join(", ")} always may. ` : ""}Tick agents from other projects; untick to take it back.`,

  });

  if (!picked) return;

  const want = new Set(picked.map((p) => p.agent));

  const changes = items

    .filter((i) => want.has(i.agent) !== i.picked)

    .map((i) => ({ agent: i.agent, channel: name, allow: want.has(i.agent) }));

  await grant(h, changes);

}