// Spectra for VS Code: set Spectra up, chat with your agents, and give
// them their briefs, without the command line (spectra-vscode spec).
import * as vscode from "vscode";
import { Bridge } from "./bridge";
import { BriefFs, SCHEME, uriFor } from "./briefs";
import { openChannel } from "./chat";
import * as cli from "./cli";
import { Model } from "./model";
import * as setup from "./setup";
import * as views from "./views";

export async function activate(ctx: vscode.ExtensionContext): Promise<void> {
  const log = vscode.window.createOutputChannel("Spectra");
  const bridge = new Bridge(log);
  const model = new Model(bridge);
  const fsp = new BriefFs(bridge);
  ctx.subscriptions.push(log, bridge, model, vscode.workspace.registerFileSystemProvider(SCHEME, fsp, { isCaseSensitive: true }));

  for (const [id, view] of [
    ["spectra.channels", new views.Channels(model)],
    ["spectra.agents", new views.Agents(model)],
    ["spectra.inbox", new views.Inbox(model)],
    ["spectra.briefs", new views.Briefs(model)],
  ] as const) {
    ctx.subscriptions.push(vscode.window.registerTreeDataProvider(id, view));
  }

  const bar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left, 50);
  bar.command = "workbench.view.extension.spectra";
  ctx.subscriptions.push(bar);

  const set = (key: string, v: boolean) => vscode.commands.executeCommand("setContext", key, v);
  let ready = false;

  // What is set up, as contexts the walkthrough and views follow.
  async function check(): Promise<void> {
    const hasBinary = !!cli.binary();
    await set("spectra.hasBinary", hasBinary);
    const st = hasBinary ? await cli.status().catch(() => undefined) : undefined;
    await set("spectra.hasIdentity", !!st?.identity);
    const nowReady = !!st?.identity && !!(st.server || st.local.initialised) && st.reachable;
    if (nowReady !== ready) {
      ready = nowReady;
      if (ready) model.start();
      else model.stop();
    }
    await set("spectra.ready", ready);
    if (!ready) {
      bar.text = "$(radio-tower) Spectra: set up";
      bar.tooltip = st?.identity && (st.server || st.local.initialised) ? "Spectra is not answering" : "Set Spectra up";
      bar.command = st?.identity && (st.server || st.local.initialised) ? "spectra.refresh" : "spectra.setup";
      bar.show();
    }
  }

  model.onDidChange(async () => {
    await set("spectra.folderIsProject", !!model.folderProject());
    await set("spectra.hasAgent", model.agents.some((a) => !a.disabled));
    fsp.changed();
    if (model.error) {
      bar.text = "$(warning) Spectra";
      bar.tooltip = model.error;
    } else {
      const online = model.agents.filter((a) => !a.disabled && a.presence !== "offline").length;
      const unread = model.inbox.length;
      bar.text = `$(radio-tower) ${online} agent${online === 1 ? "" : "s"} · ${unread} unread`;
      bar.tooltip = `Spectra: ${model.agents.filter((a) => !a.disabled).length} agents, ${online} online; ${unread} unread for you`;
      bar.command = unread ? "spectra.inbox.focus" : "workbench.view.extension.spectra";
    }
    bar.show();
  });

  const hooks: setup.Hooks = {
    changed: async () => {
      bridge.restart();
      if (ready) model.start();
      await check();
      await model.refresh();
    },
    projects: () => model.projects,
    agents: () => model.agents,
    folderProject: () => model.folderProject(),
  };

  const radar = (page?: string) => {
    const bin = cli.binary();
    if (!bin) return;
    const t = vscode.window.createTerminal({ name: "Spectra Radar", shellPath: bin, shellArgs: ["open", ...(page ? ["--page", page] : [])] });
    t.show(true);
  };

  const cmd = (id: string, f: (...a: never[]) => unknown) => ctx.subscriptions.push(vscode.commands.registerCommand(id, f));
  cmd("spectra.setup", () => vscode.commands.executeCommand("workbench.action.openWalkthrough", `${ctx.extension.id}#spectra.setup`, false));
  cmd("spectra.checkBinary", async () => {
    await setup.checkBinary();
    await check();
  });
  cmd("spectra.createIdentity", () => setup.createIdentity(hooks));
  cmd("spectra.setupHere", () => setup.setupHere(hooks));
  cmd("spectra.connectServer", () => setup.connectServer(hooks));
  cmd("spectra.registerFolder", () => setup.registerFolder(hooks));
  cmd("spectra.linkProject", () => setup.linkProject(hooks));
  cmd("spectra.addAgent", () => setup.addAgent(hooks));
  cmd("spectra.renewAgent", (item?: vscode.TreeItem) => setup.renewAgent(hooks, typeof item?.label === "string" ? item.label : undefined));
  cmd("spectra.openChannel", async (name?: string) => {
    const pick = name ?? (await vscode.window.showQuickPick(model.channels.map((c) => c.name), { placeHolder: "Which channel?" }));
    if (pick) openChannel(ctx, bridge, model, pick);
  });
  cmd("spectra.openProjectChannel", () => openChannel(ctx, bridge, model, model.folderProject() ?? "general"));
  cmd("spectra.say", async () => {
    const channel = model.folderProject() ?? "general";
    const body = await vscode.window.showInputBox({ prompt: `Say in #${channel}, as yourself` });
    if (!body) return;
    try {
      await bridge.request("POST", `/api/v1/channels/${encodeURIComponent(channel)}/messages`, { body });
    } catch (e) {
      void vscode.window.showErrorMessage(`Spectra: ${(e as Error).message}`);
    }
  });
  cmd("spectra.editOverallBrief", () => vscode.window.showTextDocument(uriFor()));
  cmd("spectra.editProjectBrief", async (project?: string) => {
    const p = project ?? model.folderProject() ?? (await vscode.window.showQuickPick(model.projects.map((x) => x.name), { placeHolder: "Which project's brief?" }));
    if (p) await vscode.window.showTextDocument(uriFor(p));
  });
  cmd("spectra.openRadar", () => radar());
  cmd("spectra.openConstellation", () => radar("constellation"));
  cmd("spectra.refresh", async () => {
    await check();
    if (ready) await model.refresh();
  });

  await check();
  if (!ready && !ctx.globalState.get("spectra.walkthroughShown")) {
    await ctx.globalState.update("spectra.walkthroughShown", true);
    void vscode.commands.executeCommand("spectra.setup");
  }
}

export function deactivate(): void {
  // The bridge ends with its input, which closes when the extension host does.
}