// Activation: find oxy, find repositories, wire the source control view,

// decorations, the content provider, and the commands (spec §3).

import * as vscode from "vscode";

import { OxygenAPI, RemoteProvider, RemoteTarget, RepositoryHandle, linkedLines, pickProvider, repositoryFor as rootFor, stateSpec } from "./api";

import { basename, join } from "node:path";

import { Oxy, OxyError, ShowInfo, findBinary } from "./oxy";

import { Repository, OxyResourceState, SubrepoState } from "./repository";

import { BisectProvider, TrustProvider } from "./panels";

import { OxyContentProvider, SCHEME, baseUri, oxyUri } from "./contentProvider";

import { OxyDecorationProvider } from "./decorations";

import { OperationItem, OperationsProvider, timeAgo } from "./operations";

import { BlameController } from "./blame";

import { HistoryPanel } from "./history";

import { MessageHistory, conflictMarkerLines, placeholder, signingLabel } from "./commitbox";

import { readFile, stat } from "node:fs/promises";

import { ConflictCodeLensProvider, acceptSides, keepCandidate, markResolved } from "./conflicts";

import { parsePlanQuery, parseResolveQuery, sameRemote } from "./handoff";

const MIN_VERSION = { format: 2, protocol: 1 };

let output: vscode.OutputChannel;

let oxy: Oxy;

let contentProvider: OxyContentProvider;

let decorations: OxyDecorationProvider;

let operations: OperationsProvider;

let blame: BlameController;

let conflictLenses: ConflictCodeLensProvider;

let bisectView: BisectProvider;

let trustView: TrustProvider;

const repositories = new Map<string, Repository>();

export async function activate(context: vscode.ExtensionContext): Promise<OxygenAPI | undefined> {

  extensionContext = context;

  output = vscode.window.createOutputChannel("Oxygen");

  context.subscriptions.push(output);

  output.appendLine(`Oxygen extension ${context.extension.packageJSON.version} activating; folders: ${(vscode.workspace.workspaceFolders ?? []).map((f) => f.uri.fsPath).join(", ") || "(none)"}`);

  oxy = new Oxy(findBinary(vscode.workspace.getConfiguration("oxygen").get<string>("path")), (line) => output.appendLine(line));

  try {

    const v = await oxy.version();

    output.appendLine(`oxy ${v.version} (format ${v.format}, protocol ${v.protocol}) at ${oxy.binary}`);

    if (v.format < MIN_VERSION.format || v.protocol < MIN_VERSION.protocol) {

      void vscode.window.showWarningMessage(`Oxygen: oxy ${v.version} is older than this extension supports.`);

    }

  } catch (e) {

    const pick = await vscode.window.showErrorMessage(`Oxygen: could not run oxy (${(e as Error).message}). Set "oxygen.path" or put oxy on your PATH.`, "Open Settings");

    if (pick === "Open Settings") {

      void vscode.commands.executeCommand("workbench.action.openSettings", "oxygen.path");

    }

    return;

  }

  contentProvider = new OxyContentProvider(oxy);

  context.subscriptions.push(vscode.workspace.registerTextDocumentContentProvider(SCHEME, contentProvider));

  decorations = new OxyDecorationProvider(() => [...repositories.values()]);

  context.subscriptions.push(decorations);

  operations = new OperationsProvider(() => [...repositories.values()]);

  context.subscriptions.push(vscode.window.registerTreeDataProvider("oxygen.operations", operations));

  blame = new BlameController(() => [...repositories.values()]);

  context.subscriptions.push(blame);

  conflictLenses = new ConflictCodeLensProvider(() => [...repositories.values()]);

  context.subscriptions.push(vscode.languages.registerCodeLensProvider({ scheme: "file" }, conflictLenses));

  bisectView = new BisectProvider(() => [...repositories.values()]);

  trustView = new TrustProvider(() => [...repositories.values()]);

  context.subscriptions.push(vscode.window.registerTreeDataProvider("oxygen.bisect", bisectView), vscode.window.registerTreeDataProvider("oxygen.trust", trustView));

  context.subscriptions.push(

    vscode.commands.registerCommand("oxygen.refresh", async () => {

      await Promise.all([...repositories.values()].map((r) => r.refresh()));

    }),

    vscode.commands.registerCommand("oxygen.showOutput", () => output.show()),

    vscode.commands.registerCommand("oxygen.openOnRemote", (arg?: Repository | vscode.SourceControl | LinkArg) =>

      openOnRemote(undefined, arg instanceof Repository ? arg : undefined, "open", arg instanceof Repository || isSourceControl(arg) ? undefined : (arg as LinkArg)),

    ),

    vscode.commands.registerCommand("oxygen.copyRemoteLink", (arg?: LinkArg) => openOnRemote(undefined, undefined, "copy", arg)),

    vscode.commands.registerCommand("oxygen.copyPermalink", (arg?: LinkArg) => openOnRemote(undefined, undefined, "permalink", arg)),

    vscode.commands.registerCommand("oxygen.openChangeOnRemote", (root: string, hash: string) => openOnRemote({ kind: "change", hash }, repositories.get(root))),

    vscode.commands.registerCommand("oxygen.openFile", (state?: OxyResourceState) => state && vscode.commands.executeCommand("vscode.open", state.resourceUri)),

    vscode.commands.registerCommand("oxygen.openChanges", (state?: OxyResourceState) => state && openChanges(state)),

    vscode.commands.registerCommand("oxygen.openBaseVersion", (state?: OxyResourceState) => state && vscode.commands.executeCommand("vscode.open", baseUri(state.repository.root, state.path))),

    vscode.commands.registerCommand("oxygen.commit", (arg?: Repository | vscode.SourceControl) => commit(arg)),

    vscode.commands.registerCommand("oxygen.showLog", () => showLog()),

    vscode.commands.registerCommand("oxygen.init", () => initRepository()),

    vscode.commands.registerCommand("oxygen.discard", (state?: OxyResourceState, states?: OxyResourceState[]) => discard(states?.length ? states : state ? [state] : [])),

    vscode.commands.registerCommand("oxygen.commitSelected", (state?: OxyResourceState, states?: OxyResourceState[]) => commitSelected(states?.length ? states : state ? [state] : [])),

    vscode.commands.registerCommand("oxygen.commitHunks", (arg?: Repository | vscode.SourceControl) => commitHunks(arg)),

    vscode.commands.registerCommand("oxygen.amend", (arg?: Repository | vscode.SourceControl) => amend(arg)),

    vscode.commands.registerCommand("oxygen.history.split", (ctx?: { root?: string; hash?: string }) => historyContext(ctx, "split")),

    vscode.commands.registerCommand("oxygen.history.squash", (ctx?: { root?: string; hash?: string }) => historyContext(ctx, "squash")),

    vscode.commands.registerCommand("oxygen.history.rebase", (ctx?: { root?: string; hash?: string }) => historyContext(ctx, "rebase")),

    vscode.commands.registerCommand("oxygen.amendMode", (arg?: Repository | vscode.SourceControl) => toggleAmend(arg, true)),

    vscode.commands.registerCommand("oxygen.leaveAmendMode", (arg?: Repository | vscode.SourceControl) => toggleAmend(arg, false)),

    vscode.commands.registerCommand("oxygen.messageHistory", (arg?: Repository | vscode.SourceControl) => messageHistory(arg)),

    vscode.commands.registerCommand("oxygen.undo", (arg?: Repository | vscode.SourceControl) => undo(arg, 1)),

    vscode.commands.registerCommand("oxygen.undoTo", (item?: OperationItem) => item && undo(item.repository, item.stepsBack)),

    vscode.commands.registerCommand("oxygen.refreshOperations", () => operations.refresh()),

    vscode.commands.registerCommand("oxygen.switchBookmark", (arg?: Repository | vscode.SourceControl) => switchBookmark(arg)),

    vscode.commands.registerCommand("oxygen.createBookmark", (arg?: Repository | vscode.SourceControl) => createBookmark(arg)),

    vscode.commands.registerCommand("oxygen.mergeBookmark", (arg?: Repository | vscode.SourceControl) => mergeBookmark(arg)),

    vscode.commands.registerCommand("oxygen.deleteBookmark", (arg?: Repository | vscode.SourceControl) => deleteBookmark(arg)),

    vscode.commands.registerCommand("oxygen.fetch", (arg?: Repository | vscode.SourceControl) => fetch(arg)),

    vscode.commands.registerCommand("oxygen.pull", (arg?: Repository | vscode.SourceControl) => pull(arg)),

    vscode.commands.registerCommand("oxygen.push", (arg?: Repository | vscode.SourceControl) => push(arg, false)),

    vscode.commands.registerCommand("oxygen.pushBookmark", (arg?: Repository | vscode.SourceControl) => push(arg, true)),

    vscode.commands.registerCommand("oxygen.sync", (arg?: Repository | vscode.SourceControl) => sync(arg)),

    vscode.commands.registerCommand("oxygen.showHistory", (arg?: Repository | vscode.SourceControl) => {

      const repo = repositoryFor(arg);

      if (repo) {

        HistoryPanel.show(repo, (hash) => void showChange(repo.root, hash));

      }

    }),

    vscode.commands.registerCommand("oxygen.fileHistory", (uri?: vscode.Uri) => fileHistory(uri ?? vscode.window.activeTextEditor?.document.uri)),

    vscode.commands.registerCommand("oxygen.toggleBlame", () => blame.toggle()),

    vscode.commands.registerCommand("oxygen.showChange", (root?: string, hash?: string) => root && hash && showChange(root, hash)),

    vscode.commands.registerCommand("oxygen.acceptSides", (uri: vscode.Uri, index: number, keep: number[]) => acceptSides(uri, index, keep).catch(showError)),

    vscode.commands.registerCommand("oxygen.keepCandidate", (state?: OxyResourceState) => state && keepCandidate(state.repository, state.path).catch(showError)),

    vscode.commands.registerCommand("oxygen.markResolved", (arg?: Repository | vscode.SourceControl) => {

      const repo = repositoryFor(arg);

      return repo && markResolved(repo).catch(showError);

    }),

    vscode.commands.registerCommand("oxygen.openConflict", (state?: OxyResourceState) => state && vscode.commands.executeCommand("vscode.open", state.resourceUri)),

    vscode.commands.registerCommand("oxygen.openSubrepo", (state?: SubrepoState) => state && openSubrepo(state)),

    vscode.commands.registerCommand("oxygen.updateSubrepo", (state?: SubrepoState) => state && updateSubrepos(state.repository, true, [state.info.path])),

    vscode.commands.registerCommand("oxygen.updateSubrepos", (arg?: Repository | vscode.SourceControl) => {

      const repo = repositoryFor(arg);

      return repo && updateSubrepos(repo, true, []);

    }),

    vscode.commands.registerCommand("oxygen.bisectStart", (arg?: Repository) => bisect(arg, (r) => r.oxy.bisectStart(r.root).then(() => "Started; mark a good and a bad change"))),

    vscode.commands.registerCommand("oxygen.bisectGood", (arg?: Repository, changes?: string[]) => bisectMark(arg, "good", changes)),

    vscode.commands.registerCommand("oxygen.bisectBad", (arg?: Repository, changes?: string[]) => bisectMark(arg, "bad", changes)),

    vscode.commands.registerCommand("oxygen.bisectSkip", (arg?: Repository) => bisect(arg, (r) => r.oxy.bisectMark(r.root, "skip"))),

    vscode.commands.registerCommand("oxygen.bisectRun", (arg?: Repository) => bisectRun(arg)),

    vscode.commands.registerCommand("oxygen.bisectReset", (arg?: Repository) => bisect(arg, (r) => r.oxy.bisectReset(r.root).then(() => "Bisect reset; working copy restored"))),

    vscode.commands.registerCommand("oxygen.refreshBisect", () => bisectView.refresh()),

    vscode.commands.registerCommand("oxygen.refreshTrust", () => trustView.refresh()),

    vscode.commands.registerCommand("oxygen.verify", (arg?: Repository | vscode.SourceControl) => verify(arg)),

    vscode.commands.registerCommand("oxygen.tags", (arg?: Repository | vscode.SourceControl) => tags(arg)),

    vscode.commands.registerCommand("oxygen.createTag", (arg?: Repository | vscode.SourceControl) => createTag(arg)),

    vscode.commands.registerCommand("oxygen.addWorkspace", (arg?: Repository | vscode.SourceControl) => addWorkspace(arg)),

    vscode.commands.registerCommand("oxygen.clone", () => cloneRepository()),

    vscode.window.registerUriHandler({ handleUri: (uri) => handleUri(uri) }),

    vscode.workspace.onDidChangeWorkspaceFolders(() => void discover()),

    vscode.workspace.onDidChangeConfiguration((e) => {

      if (e.affectsConfiguration("oxygen.path")) {

        void vscode.window.showInformationMessage("Oxygen: reload the window to use the new oxy path.");

      }

      if (e.affectsConfiguration("oxygen")) {

        decorations.refresh();

        for (const r of repositories.values()) {

          r.scheduleRefresh();

        }

      }

    }),

  );

  context.subscriptions.push({ dispose: () => repositories.forEach((r) => r.dispose()) });

  await discover();

  return buildApi();

}

// ---------------------------------------------------------------- exported API

const remoteProviders: RemoteProvider[] = [];

const onDidChangeRepositoriesEmitter = new vscode.EventEmitter<void>();

const onDidChangeStatusEmitter = new vscode.EventEmitter<RepositoryHandle>();

function handleOf(repo: Repository): RepositoryHandle {

  return {

    root: repo.root,

    get status() {

      return repo.status;

    },

    get bookmarks() {

      return repo.bookmarks.map((b) => ({ name: b.name, heads: b.heads, current: b.current }));

    },

    get currentBookmark() {

      return repo.currentBookmark?.name;

    },

    remotes: async () => (await repo.oxy.remotes(repo.root)).map((r) => ({ name: r.name, url: r.url, ca: r.ca ?? undefined })),

    json: <T>(args: string[]) => repo.oxy.json<T>(repo.root, args),

    refresh: () => repo.refresh(),

  };

}

function buildApi(): OxygenAPI {

  return {

    version: 1,

    get repositories() {

      return [...repositories.values()].map(handleOf);

    },

    onDidChangeStatus: (listener) => onDidChangeStatusEmitter.event(listener),

    onDidChangeRepositories: (listener) => onDidChangeRepositoriesEmitter.event(listener),

    getRepository: (fsPath) => {

      const root = rootFor([...repositories.keys()], fsPath);

      const repo = root ? repositories.get(root) : undefined;

      return repo ? handleOf(repo) : undefined;

    },

    registerRemoteProvider: (provider) => {

      remoteProviders.push(provider);

      void vscode.commands.executeCommand("setContext", "oxygen.hasRemoteProvider", true);

      return {

        dispose: () => {

          const i = remoteProviders.indexOf(provider);

          if (i >= 0) {

            remoteProviders.splice(i, 1);

          }

          void vscode.commands.executeCommand("setContext", "oxygen.hasRemoteProvider", remoteProviders.length > 0);

        },

      };

    },

    remoteProviders: () => [...remoteProviders],

  };

}

/** What a remote-link command does with the URL. */

type LinkMode = "open" | "copy" | "permalink";

/** The editor gutter passes `{ lineNumber, uri }`; an editor title menu passes the file's Uri. */

type LinkArg = { lineNumber?: number; uri?: vscode.Uri } | vscode.Uri | undefined;

/**

 * Open or copy a link to the current repository, file or change on

 * whichever provider knows its remote. For a file, the lines are the

 * gutter's clicked line or the selection; `permalink` pins the link to the

 * bookmark's current state (its heads), so it keeps pointing at these lines.

 */

async function openOnRemote(target?: RemoteTarget, repoArg?: Repository, mode: LinkMode = "open", arg?: LinkArg): Promise<void> {

  const argUri = arg instanceof vscode.Uri ? arg : arg?.uri;

  const clicked = arg && !(arg instanceof vscode.Uri) ? arg.lineNumber : undefined;

  const editor = vscode.window.activeTextEditor;

  const docUri = argUri ?? editor?.document.uri;

  const repo = repoArg ?? (docUri ? repositoryFor2(docUri) : undefined) ?? [...repositories.values()][0];

  if (!repo) {

    void vscode.window.showInformationMessage("Oxygen: no repository is open.");

    return;

  }

  const remotes = (await repo.oxy.remotes(repo.root)).map((r) => ({ name: r.name, url: r.url }));

  const pick = pickProvider(remoteProviders, remotes);

  if (!pick) {

    void vscode.window.showInformationMessage("Oxygen: no extension knows this repository's remotes. Install a forge extension such as OxygenHub.");

    return;

  }

  let t: RemoteTarget = target ?? { kind: "repository" };

  let note = "";

  if (!target && docUri) {

    const rel = repo.relativePath(docUri);

    if (rel) {

      const bookmark = repo.currentBookmark;

      let reference = bookmark?.name ?? "main";

      if (mode === "permalink") {

        const spec = stateSpec(bookmark?.heads ?? []);

        if (!spec) {

          void vscode.window.showInformationMessage("Oxygen: this bookmark has no committed state to link to yet.");

          return;

        }

        reference = spec;

      }

      const sameDoc = editor && editor.document.uri.toString() === docUri.toString();

      const sel = sameDoc

        ? { start: editor.selection.start.line + 1, end: editor.selection.end.line + 1, endColumn: editor.selection.end.character, empty: editor.selection.isEmpty }

        : { start: clicked ?? 1, end: clicked ?? 1, endColumn: 0, empty: true };

      const lines = clicked !== undefined || sameDoc ? linkedLines(clicked, sel) : {};

      t = { kind: "file", reference, path: rel, ...lines };

      // Lines are counted in the editor; say so when they may not match the remote.

      const edited = repo.status?.paths.some((p) => p.path === rel);

      if (edited || (sameDoc && editor.document.isDirty)) {

        note = " The file has uncommitted edits, so the lines may differ from the remote's.";

      } else if (mode !== "permalink" && bookmark && bookmark.ahead !== null && bookmark.ahead > 0) {

        note = ` ${bookmark.name} has unpushed changes; the remote may not show them yet.`;

      }

    }

  }

  const url = pick.provider.urlFor(pick.remote.url, t);

  if (!url) {

    return;

  }

  if (mode === "open") {

    await vscode.env.openExternal(vscode.Uri.parse(url));

    if (note) {

      void vscode.window.showInformationMessage(`Oxygen:${note}`);

    }

    return;

  }

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

  const what = mode === "permalink" ? "Permalink" : "Link";

  if (note) {

    void vscode.window.showWarningMessage(`Oxygen: ${what} copied.${note}`);

  } else {

    vscode.window.setStatusBarMessage(`$(link) ${what} copied`, 4000);

  }

}

function isSourceControl(arg: unknown): arg is vscode.SourceControl {

  return typeof arg === "object" && arg !== null && "inputBox" in arg && "rootUri" in arg;

}

function repositoryFor2(uri: vscode.Uri): Repository | undefined {

  const root = rootFor([...repositories.keys()], uri.fsPath);

  return root ? repositories.get(root) : undefined;

}

export function deactivate(): void {

  for (const r of repositories.values()) {

    r.dispose();

  }

  repositories.clear();

}

/** One Repository per distinct oxy root among the workspace folders. */

async function discover(): Promise<void> {

  const wanted = new Map<string, vscode.WorkspaceFolder>();

  for (const folder of vscode.workspace.workspaceFolders ?? []) {

    const info = await oxy.root(folder.uri.fsPath);

    if (info) {

      wanted.set(info.root, folder);

    }

  }

  for (const [root, repo] of repositories) {

    if (!wanted.has(root)) {

      repo.dispose();

      repositories.delete(root);

      onDidChangeRepositoriesEmitter.fire();

    }

  }

  if (wanted.size === 0 && (vscode.workspace.workspaceFolders ?? []).length > 0) {

    output.appendLine("no Oxygen repository in the open folders (oxy root found none)");

  }

  for (const [root, folder] of wanted) {

    if (!repositories.has(root)) {

      const repo = new Repository(oxy, root, folder);

      repo.onDidChangeStatus((status) => {

        decorations.refresh();

        contentProvider.invalidate(root);

        operations.refresh();

        blame.invalidate(root);

        HistoryPanel.refresh(root);

        conflictLenses.refresh();

        bisectView.refresh();

        trustView.refresh();

        // The commit action reads as a resolution while conflicts are resolved but uncommitted.

        box(repo).resolution = status.conflicted && status.conflicts.length > 0 && status.conflicts.every((c) => c.resolved === true);

        void refreshSigning(repo);

        updateBox(repo);

      });

      repositories.set(root, repo);

      repo.onDidChangeStatus(() => onDidChangeStatusEmitter.fire(handleOf(repo)));

      onDidChangeRepositoriesEmitter.fire();

      output.appendLine(`repository ${root}`);

      await repo.refresh();

    }

  }

  void vscode.commands.executeCommand("setContext", "oxygen.hasRepository", repositories.size > 0);

}

function repositoryFor(arg: Repository | vscode.SourceControl | undefined): Repository | undefined {

  if (arg instanceof Repository) {

    return arg;

  }

  if (arg && "rootUri" in arg && arg.rootUri) {

    return repositories.get(arg.rootUri.fsPath);

  }

  const active = vscode.window.activeTextEditor?.document.uri;

  for (const repo of repositories.values()) {

    if (active && repo.relativePath(active) !== undefined) {

      return repo;

    }

  }

  return repositories.size === 1 ? [...repositories.values()][0] : undefined;

}

async function openChanges(state: OxyResourceState): Promise<void> {

  const repo = state.repository;

  const title = `${basename(state.path)} (base ↔ working copy)`;

  if (state.status === "Added") {

    await vscode.commands.executeCommand("vscode.open", state.resourceUri);

    return;

  }

  if (state.status === "Removed") {

    await vscode.commands.executeCommand("vscode.open", baseUri(repo.root, state.path));

    return;

  }

  await vscode.commands.executeCommand("vscode.diff", baseUri(repo.root, state.path), state.resourceUri, title);

}

async function commit(arg: Repository | vscode.SourceControl | undefined): Promise<void> {

  const repo = repositoryFor(arg);

  if (!repo) {

    void vscode.window.showErrorMessage("Oxygen: no repository for the active file.");

    return;

  }

  if (box(repo).amend) {

    await amend(repo);

    return;

  }

  let message = repo.sourceControl.inputBox.value.trim();

  if (!message) {

    message = (await vscode.window.showInputBox({ prompt: "Commit message", placeHolder: "What did you change?" }))?.trim() ?? "";

  }

  if (!message) {

    return;

  }

  if (!(await markersOk(repo))) {

    return;

  }

  try {

    await vscode.window.withProgress({ location: vscode.ProgressLocation.SourceControl, title: "Committing" }, () => repo.oxy.commit(repo.root, message));

    remember(repo, message);

    repo.sourceControl.inputBox.value = "";

    await repo.refresh();

  } catch (e) {

    showError(e);

  }

}

async function initRepository(): Promise<void> {

  const folders = vscode.workspace.workspaceFolders ?? [];

  if (folders.length === 0) {

    void vscode.window.showErrorMessage("Oxygen: open a folder first.");

    return;

  }

  const folder = folders.length === 1 ? folders[0] : await vscode.window.showWorkspaceFolderPick({ placeHolder: "Folder to initialize as an Oxygen repository" });

  if (!folder) {

    return;

  }

  try {

    await oxy.check(folder.uri.fsPath, ["init"]);

    await discover();

    void vscode.window.showInformationMessage(`Oxygen: initialized ${folder.name}.`);

  } catch (e) {

    showError(e);

  }

}

async function discard(states: OxyResourceState[]): Promise<void> {

  if (states.length === 0) {

    return;

  }

  const repo = states[0].repository;

  const names = states.length === 1 ? basename(states[0].path) : `${states.length} files`;

  const pick = await vscode.window.showWarningMessage(`Discard changes in ${names}? This cannot be undone with oxy undo.`, { modal: true }, "Discard");

  if (pick !== "Discard") {

    return;

  }

  try {

    await repo.oxy.discard(repo.root, states.map((s) => s.path));

    await repo.refresh();

  } catch (e) {

    showError(e);

  }

}

async function commitSelected(states: OxyResourceState[]): Promise<void> {

  if (states.length === 0) {

    return;

  }

  const repo = states[0].repository;

  const message = await askMessage(repo, `Commit ${states.length === 1 ? basename(states[0].path) : `${states.length} files`}`);

  if (!message) {

    return;

  }

  if (!(await markersOk(repo, states.map((s) => s.path)))) {

    return;

  }

  try {

    await vscode.window.withProgress({ location: vscode.ProgressLocation.SourceControl, title: "Committing" }, () => repo.oxy.commit(repo.root, message, states.map((s) => s.path)));

    remember(repo, message);

    repo.sourceControl.inputBox.value = "";

    await repo.refresh();

  } catch (e) {

    showError(e);

  }

}

async function commitHunks(arg: Repository | vscode.SourceControl | undefined): Promise<void> {

  const repo = repositoryFor(arg);

  if (!repo) {

    return;

  }

  let hunks;

  try {

    hunks = await repo.oxy.hunks(repo.root);

  } catch (e) {

    showError(e);

    return;

  }

  if (hunks.length === 0) {

    void vscode.window.showInformationMessage("Oxygen: nothing to commit.");

    return;

  }

  const picks = await vscode.window.showQuickPick(

    hunks.map((h) => ({

      label: `$(diff) ${h.path}`,

      description: `#${h.index}`,

      detail: h.text.split("\n").filter((l) => l.startsWith("+") || l.startsWith("-") || l.startsWith("A ") || l.startsWith("D ") || l.startsWith("R ")).slice(0, 3).join("  ").slice(0, 160),

      hunk: h,

      picked: false,

    })),

    { canPickMany: true, placeHolder: "Choose the hunks to commit; anything a chosen hunk needs comes along" },

  );

  if (!picks || picks.length === 0) {

    return;

  }

  const message = await askMessage(repo, `Commit ${picks.length} hunk${picks.length === 1 ? "" : "s"}`);

  if (!message) {

    return;

  }

  try {

    await repo.oxy.commitHunks(repo.root, message, picks.map((p) => p.hunk.index));

    remember(repo, message);

    repo.sourceControl.inputBox.value = "";

    await repo.refresh();

  } catch (e) {

    showError(e);

  }

}

async function amend(arg: Repository | vscode.SourceControl | undefined): Promise<void> {

  const repo = repositoryFor(arg);

  if (!repo) {

    return;

  }

  const message = repo.sourceControl.inputBox.value.trim();

  if (!(await markersOk(repo))) {

    return;

  }

  try {

    await vscode.window.withProgress({ location: vscode.ProgressLocation.SourceControl, title: "Amending" }, () => repo.oxy.amend(repo.root, message || undefined));

    remember(repo, message);

    repo.sourceControl.inputBox.value = "";

    setAmend(repo, false);

    await repo.refresh();

  } catch (e) {

    showError(e);

  }

}

async function undo(arg: Repository | vscode.SourceControl | undefined, steps: number): Promise<void> {

  const repo = repositoryFor(arg);

  if (!repo || steps <= 0) {

    return;

  }

  if (steps > 1) {

    const pick = await vscode.window.showWarningMessage(`Undo the last ${steps} operations?`, { modal: true }, "Undo");

    if (pick !== "Undo") {

      return;

    }

  }

  try {

    let last = "";

    for (let i = 0; i < steps; i++) {

      last = await repo.oxy.undo(repo.root);

    }

    await repo.refresh();

    vscode.window.setStatusBarMessage(`$(discard) ${last || "Undone"}`, 4000);

  } catch (e) {

    showError(e);

  }

}

// ---------------------------------------------------------------- subrepos, bisect, trust, tags, workspaces, clone

async function openSubrepo(state: SubrepoState): Promise<void> {

  if (!state.info.actual) {

    const pick = await vscode.window.showInformationMessage(`${state.info.path} is not checked out yet.`, "Update --init");

    if (pick) {

      await updateSubrepos(state.repository, true, [state.info.path]);

    }

    return;

  }

  const pick = await vscode.window.showQuickPick(

    [

      { label: "$(folder-opened) Open in new window", action: "window" },

      { label: "$(cloud-download) Update to the pin", action: "update", description: state.info.at_pin ? "already at pin" : "moves the nested repository" },

    ],

    { placeHolder: `${state.info.path} · ${state.decorations.tooltip}` },

  );

  if (pick?.action === "window") {

    await vscode.commands.executeCommand("vscode.openFolder", state.resourceUri, { forceNewWindow: true });

  } else if (pick?.action === "update") {

    await updateSubrepos(state.repository, true, [state.info.path]);

  }

}

async function updateSubrepos(repo: Repository, init: boolean, paths: string[]): Promise<void> {

  try {

    const out = await vscode.window.withProgress({ location: vscode.ProgressLocation.SourceControl, title: "Updating subrepos" }, () => repo.oxy.submoduleUpdate(repo.root, init, paths));

    await repo.refresh();

    const lines = out.trim().split("\n").filter(Boolean);

    if (lines.some((l) => /missing|uncommitted|✖|x /.test(l))) {

      void vscode.window.showWarningMessage(`Oxygen: ${lines.join("; ")}`);

    } else {

      vscode.window.setStatusBarMessage(`$(check) ${lines.join("; ") || "Subrepos up to date"}`, 5000);

    }

  } catch (e) {

    showError(e);

  }

}

async function bisect(arg: Repository | undefined, run: (repo: Repository) => Promise<string>): Promise<void> {

  const repo = arg instanceof Repository ? arg : repositoryFor(undefined);

  if (!repo) {

    return;

  }

  try {

    const out = await run(repo);

    await repo.refresh();

    vscode.window.setStatusBarMessage(`$(search) ${out.split("\n")[0]}`, 5000);

  } catch (e) {

    showError(e);

  }

}

async function bisectMark(arg: Repository | undefined, verdict: "good" | "bad", changes?: string[]): Promise<void> {

  const repo = arg instanceof Repository ? arg : repositoryFor(undefined);

  if (!repo) {

    return;

  }

  let picked = changes;

  if (picked === undefined) {

    const status = await repo.oxy.bisectStatus(repo.root).catch(() => null);

    if (!status || status.state === "need-marks") {

      const value = await vscode.window.showInputBox({ prompt: `A change, bookmark or tag known to be ${verdict}`, placeHolder: verdict === "good" ? "v1.2 or a ChangeId prefix" : "main" });

      if (!value?.trim()) {

        return;

      }

      picked = value.trim().split(/\s+/);

    } else {

      picked = [];

    }

  }

  await bisect(repo, (r) => r.oxy.bisectMark(r.root, verdict, picked));

}

async function bisectRun(arg: Repository | undefined): Promise<void> {

  const repo = arg instanceof Repository ? arg : repositoryFor(undefined);

  if (!repo) {

    return;

  }

  const value = await vscode.window.showInputBox({ prompt: "Command to run for each step (exit 0 good, 125 skip, anything else bad)", placeHolder: "make test" });

  if (!value?.trim()) {

    return;

  }

  await bisect(repo, (r) => Promise.resolve(vscode.window.withProgress({ location: vscode.ProgressLocation.Notification, title: "Oxygen: bisecting", cancellable: false }, () => r.oxy.bisectRun(r.root, ["sh", "-c", value.trim()]))));

}

async function verify(arg: Repository | vscode.SourceControl | undefined): Promise<void> {

  const repo = repositoryFor(arg);

  if (!repo) {

    return;

  }

  try {

    const results = await repo.oxy.verify(repo.root);

    const icon = (s: string, revoked: boolean) => (s === "invalid" ? "$(error)" : s === "unsigned" ? "$(circle-outline)" : revoked ? "$(warning)" : "$(verified)");

    const pick = await vscode.window.showQuickPick(

      results.map((r) => ({

        label: `${icon(r.status, r.revoked)} ${r.change_id.slice(0, 8)} ${r.status}${r.revoked ? " (key revoked)" : ""}`,

        description: r.name ?? "",

        detail: r.reason ?? undefined,

        hash: r.hash,

      })),

      { placeHolder: `${results.length} changes; ${results.filter((r) => r.status === "invalid").length} invalid`, matchOnDescription: true },

    );

    if (pick) {

      await showChange(repo.root, pick.hash);

    }

  } catch (e) {

    showError(e);

  }

}

async function tags(arg: Repository | vscode.SourceControl | undefined): Promise<void> {

  const repo = repositoryFor(arg);

  if (!repo) {

    return;

  }

  try {

    const list = await repo.oxy.tags(repo.root);

    if (list.length === 0) {

      const pick = await vscode.window.showInformationMessage("Oxygen: no tags yet.", "Create tag");

      if (pick) {

        await createTag(repo);

      }

      return;

    }

    const pick = await vscode.window.showQuickPick(

      list.map((t) => ({ label: `$(tag) ${t.name}`, description: `${t.heads.length} head${t.heads.length === 1 ? "" : "s"}${t.signer ? ` · signed by ${t.signer}` : ""}`, detail: t.message || undefined, tag: t })),

      { placeHolder: "Check out a tag's state" },

    );

    if (!pick) {

      return;

    }

    await repo.oxy.checkout(repo.root, [pick.tag.name]);

    await repo.refresh();

  } catch (e) {

    if (e instanceof OxyError && e.message.includes("has changes")) {

      void vscode.window.showWarningMessage("Oxygen: commit or discard your changes before checking out a tag.");

      return;

    }

    showError(e);

  }

}

async function createTag(arg: Repository | vscode.SourceControl | undefined): Promise<void> {

  const repo = repositoryFor(arg);

  if (!repo) {

    return;

  }

  const name = await vscode.window.showInputBox({ prompt: "Tag name (tags the current bookmark's heads)" });

  if (!name?.trim()) {

    return;

  }

  const message = (await vscode.window.showInputBox({ prompt: "Tag message (optional)" })) ?? "";

  try {

    await repo.oxy.tagCreate(repo.root, name.trim(), [], message);

    await repo.refresh();

    vscode.window.setStatusBarMessage(`$(tag) Tagged ${name.trim()}`, 4000);

  } catch (e) {

    showError(e);

  }

}

async function addWorkspace(arg: Repository | vscode.SourceControl | undefined): Promise<void> {

  const repo = repositoryFor(arg);

  if (!repo) {

    return;

  }

  const folders = await vscode.window.showOpenDialog({ canSelectFiles: false, canSelectFolders: true, canSelectMany: false, openLabel: "Create workspace here", title: "Folder for the new workspace (must be empty or absent)" });

  if (!folders?.[0]) {

    return;

  }

  try {

    await repo.oxy.workspaceAdd(repo.root, folders[0].fsPath);

    const pick = await vscode.window.showInformationMessage(`Oxygen: workspace created at ${folders[0].fsPath}.`, "Open in new window");

    if (pick) {

      await vscode.commands.executeCommand("vscode.openFolder", folders[0], { forceNewWindow: true });

    }

  } catch (e) {

    showError(e);

  }

}

/**

 * vscode://oxygen.oxygen-vscode/resolve?url=…&bookmark=…&path=… from

 * OxygenHub's conflict resolver: find the open repository with that remote

 * (or offer to clone it), switch to the bookmark if asked to, pull it, and

 * open the file, where the conflict lenses take over.

 */

async function handleUri(uri: vscode.Uri): Promise<void> {

  if (uri.path === "/plan") {

    return applyPlan(uri);

  }

  if (uri.path !== "/resolve") {

    return;

  }

  const req = parseResolveQuery(uri.query);

  if (typeof req === "string") {

    vscode.window.showErrorMessage(`Oxygen: cannot open this conflict: ${req}.`);

    return;

  }

  let found: { repo: Repository; remote: string } | undefined;

  for (const repo of repositories.values()) {

    const remotes = await repo.oxy.remotes(repo.root).catch(() => []);

    const r = remotes.find((x) => sameRemote(x.url, req.url));

    if (r) {

      found = { repo, remote: r.name };

      break;

    }

  }

  if (!found) {

    const pick = await vscode.window.showInformationMessage(

      `Oxygen: no open folder is a checkout of ${req.url}. Clone it, open it, then follow the link again.`,

      "Clone…",

    );

    if (pick) {

      await cloneRepository(req.url);

    }

    return;

  }

  const { repo, remote } = found;

  try {

    if (repo.currentBookmark?.name !== req.bookmark) {

      const ok = await vscode.window.showInformationMessage(

        `Oxygen: the conflict is on ${req.bookmark}; this checkout is on ${repo.currentBookmark?.name ?? "another bookmark"}. Switch?`,

        { modal: true },

        "Switch",

      );

      if (!ok) {

        return;

      }

      await vscode.window.withProgress({ location: vscode.ProgressLocation.SourceControl, title: `Switching to ${req.bookmark}` }, () =>

        repo.oxy.bookmarkSwitch(repo.root, req.bookmark),

      );

    }

    await vscode.window.withProgress({ location: vscode.ProgressLocation.Notification, title: `Oxygen: pulling ${req.bookmark}` }, () =>

      repo.oxy.pull(repo.root, remote),

    );

    await repo.refresh();

    await vscode.commands.executeCommand("vscode.open", vscode.Uri.joinPath(vscode.Uri.file(repo.root), req.path));

  } catch (e) {

    showError(e);

  }

}

/** The open checkout whose remote is `url`, with that remote's name. */

async function checkoutOf(url: string): Promise<{ repo: Repository; remote: string } | undefined> {

  for (const repo of repositories.values()) {

    const remotes = await repo.oxy.remotes(repo.root).catch(() => []);

    const r = remotes.find((x) => sameRemote(x.url, url));

    if (r) {

      return { repo, remote: r.name };

    }

  }

  return undefined;

}

/**

 * vscode://oxygen.oxygen-vscode/plan?… from OxygenHub's swimlanes: squash

 * or rebase a change of a proposal's bookmark here, where it is signed as

 * you, then push the rewritten bookmark.

 */

async function applyPlan(uri: vscode.Uri): Promise<void> {

  const plan = parsePlanQuery(uri.query);

  if (typeof plan === "string") {

    vscode.window.showErrorMessage(`Oxygen: cannot apply this plan: ${plan}.`);

    return;

  }

  const found = await checkoutOf(plan.url);

  if (!found) {

    const pick = await vscode.window.showInformationMessage(`Oxygen: no open folder is a checkout of ${plan.url}. Clone it, open it, then follow the link again.`, "Clone…");

    if (pick) {

      await cloneRepository(plan.url);

    }

    return;

  }

  const { repo, remote } = found;

  const [c, t] = [plan.change.slice(0, 12), plan.target.slice(0, 12)];

  const what = plan.kind === "squash" ? `Squash #${c} into #${t}` : `Rebase #${c} onto #${t}`;

  const ok = await vscode.window.showInformationMessage(`Oxygen: ${what} on ${plan.bookmark}? The rewritten changes are signed as you.`, { modal: true }, "Apply");

  if (!ok) {

    return;

  }

  try {

    if (repo.currentBookmark?.name !== plan.bookmark) {

      await repo.oxy.bookmarkSwitch(repo.root, plan.bookmark);

    }

    await repo.oxy.pull(repo.root, remote);

    await vscode.window.withProgress({ location: vscode.ProgressLocation.SourceControl, title: what }, () =>

      plan.kind === "squash"

        ? repo.oxy.squash(repo.root, `#${plan.change}`, `#${plan.target}`)

        : repo.oxy.rebase(repo.root, `#${plan.change}`, [`#${plan.target}`]),

    );

    await repo.refresh();

    const push = await vscode.window.showInformationMessage(`Oxygen: ${what} done. Push ${plan.bookmark}? Its history changed, so this replaces it on ${remote}.`, "Push");

    if (push) {

      await vscode.window.withProgress({ location: vscode.ProgressLocation.Notification, title: `Oxygen: pushing ${plan.bookmark}` }, () =>

        repo.oxy.push(repo.root, remote, plan.bookmark, true),

      );

    }

  } catch (e) {

    showError(e);

  }

}

async function cloneRepository(prefill?: string): Promise<void> {

  const url = await vscode.window.showInputBox({ prompt: "Repository to clone (path or https URL)", placeHolder: "https://host:8890/project", value: prefill });

  if (!url?.trim()) {

    return;

  }

  const parent = await vscode.window.showOpenDialog({ canSelectFiles: false, canSelectFolders: true, canSelectMany: false, openLabel: "Clone into this folder" });

  if (!parent?.[0]) {

    return;

  }

  const name = url.trim().replace(/\/+$/, "").split("/").pop()?.replace(/\.oxy$/, "") || "repository";

  const dest = vscode.Uri.joinPath(parent[0], name);

  try {

    await vscode.window.withProgress({ location: vscode.ProgressLocation.Notification, title: `Oxygen: cloning ${name}` }, () => oxy.clone(parent[0].fsPath, url.trim(), dest.fsPath));

    const pick = await vscode.window.showInformationMessage(`Oxygen: cloned into ${dest.fsPath}.`, "Open", "Open in new window");

    if (pick) {

      await vscode.commands.executeCommand("vscode.openFolder", dest, { forceNewWindow: pick === "Open in new window" });

    }

  } catch (e) {

    showError(e);

  }

}

// ---------------------------------------------------------------- history

async function showChange(root: string, hash: string): Promise<void> {

  const repo = repositories.get(root);

  if (!repo) {

    return;

  }

  let info;

  try {

    info = await repo.oxy.show(repo.root, `#${hash.slice(0, 12)}`);

  } catch (e) {

    showError(e);

    return;

  }

  const subject = info.message.split("\n")[0];

  type Item = vscode.QuickPickItem & { action: string; path?: string };

  const items: Item[] = [

    { label: "$(diff) Show diff", description: `${info.files.length} file${info.files.length === 1 ? "" : "s"}`, action: "diff" },

    { label: "$(arrow-right) Check out this state", description: "the change and its dependencies", action: "checkout" },

    { label: "$(edit) Describe…", description: "change the message", action: "describe" },

    { label: "$(tag) Tag…", action: "tag" },

    { label: "$(trash) Abandon", description: "drop the change; its content stays on disk if the working copy sat on it", action: "abandon" },

    ...historyItems(info),

    { label: "$(copy) Copy ChangeId", action: "copy" },

    ...info.files.map((f) => ({ label: `$(file) ${f.path}`, description: `${f.kind}${f.from ? ` from ${f.from}` : ""}`, action: "file", path: f.path })),

  ];

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

    title: `${info.change_id.slice(0, 8)}  ${subject}`,

    placeHolder: `${info.author} · ${timeAgo(info.when_ms)} · ${info.signature?.status ?? "unsigned"}${info.signature?.revoked ? " (key revoked)" : ""} · ${info.deps.length} dependenc${info.deps.length === 1 ? "y" : "ies"}`,

    matchOnDescription: true,

  });

  if (!pick) {

    return;

  }

  try {

    switch (pick.action) {

      case "diff":

      case "file": {

        const text = await repo.oxy.diffText(repo.root, `#${hash.slice(0, 12)}`);

        const body = `# ${info.change_id.slice(0, 8)} ${subject}\n# ${info.author} · ${new Date(info.when_ms).toLocaleString()}\n\n${text}`;

        const doc = await vscode.workspace.openTextDocument({ content: body, language: "diff" });

        await vscode.window.showTextDocument(doc, { preview: true });

        return;

      }

      case "checkout":

        await repo.oxy.checkout(repo.root, [`#${hash.slice(0, 12)}`]);

        break;

      case "describe": {

        const message = await vscode.window.showInputBox({ prompt: "New message", value: info.message });

        if (!message?.trim()) {

          return;

        }

        await repo.oxy.describe(repo.root, `#${hash.slice(0, 12)}`, message.trim());

        break;

      }

      case "tag": {

        const name = await vscode.window.showInputBox({ prompt: "Tag name" });

        if (!name?.trim()) {

          return;

        }

        await repo.oxy.tagCreate(repo.root, name.trim(), [`#${hash.slice(0, 12)}`]);

        break;

      }

      case "abandon": {

        const confirm = await vscode.window.showWarningMessage(`Abandon "${subject}"?`, { modal: true }, "Abandon");

        if (confirm !== "Abandon") {

          return;

        }

        const out = await repo.oxy.abandon(repo.root, `#${hash.slice(0, 12)}`);

        vscode.window.setStatusBarMessage(`$(trash) ${out.split("\n")[0]}`, 5000);

        break;

      }

      case "copy":

        await vscode.env.clipboard.writeText(info.change_id);

        return;

      case "split":

      case "squash":

      case "rebase":

        await historyAction(repo, info, pick.action);

        return;

    }

    await repo.refresh();

  } catch (e) {

    if (e instanceof OxyError && e.message.includes("has changes")) {

      const confirm = await vscode.window.showWarningMessage("The working copy has uncommitted changes. Discard them and check out?", { modal: true }, "Discard and check out");

      if (confirm) {

        try {

          await repo.oxy.checkout(repo.root, [`#${hash.slice(0, 12)}`], true);

          await repo.refresh();

        } catch (e2) {

          showError(e2);

        }

      }

      return;

    }

    showError(e);

  }

}

// ------------------------------------------------ history rewriting (V6)

type HistoryAction = "split" | "squash" | "rebase";

/** The rewriting actions a change offers: split for a head with several files, squash when it has dependencies, rebase always. */

function historyItems(info: ShowInfo): (vscode.QuickPickItem & { action: string })[] {

  const items: (vscode.QuickPickItem & { action: string })[] = [];

  if (info.head && info.files.length > 1) {

    items.push({ label: "$(split-horizontal) Split…", description: "chosen files become a separate first change", action: "split" });

  }

  if (info.deps.length > 0) {

    items.push({ label: "$(fold) Squash into a dependency…", description: "fold this change into one it depends on", action: "squash" });

  }

  items.push({ label: "$(git-pull-request-go-to-changes) Rebase onto…", description: "re-express against another state", action: "rebase" });

  return items;

}

/** Run `action` on a change: choose, confirm, run, then offer Undo (oxy undo reverses every rewrite). */

async function historyAction(repo: Repository, info: ShowInfo, action: HistoryAction): Promise<void> {

  const change = `#${info.hash.slice(0, 12)}`;

  const subject = info.message.split("\n")[0] || "(no description)";

  let run: () => Promise<string>;

  let question: string;

  if (action === "split") {

    if (!info.head) {

      void vscode.window.showInformationMessage("Oxygen: only a head can be split; nothing may depend on it yet.");

      return;

    }

    const picked = await vscode.window.showQuickPick(

      info.files.map((f) => ({ label: f.path, description: f.kind, picked: false })),

      { title: `Split ${info.change_id.slice(0, 8)}: the files you choose become the first change`, canPickMany: true },

    );

    if (!picked || picked.length === 0) {

      return;

    }

    if (picked.length === info.files.length) {

      void vscode.window.showInformationMessage("Oxygen: leave at least one file for the second change.");

      return;

    }

    const paths = picked.map((p) => p.label);

    question = `Split "${subject}"? ${paths.length} file${paths.length === 1 ? "" : "s"} (${paths.join(", ")}) become a separate change; the rest stay.`;

    run = () => repo.oxy.split(repo.root, change, paths);

  } else if (action === "squash") {

    if (info.deps.length === 0) {

      void vscode.window.showInformationMessage("Oxygen: this change has no dependency to fold into.");

      return;

    }

    const log = await repo.oxy.log(repo.root, 500);

    const byHash = new Map(log.changes.map((c) => [c.hash, c]));

    const choices = info.deps.map((d) => {

      const c = byHash.get(d);

      return { label: c ? c.message.split("\n")[0] || "(no description)" : d.slice(0, 12), description: c ? c.change_id.slice(0, 8) : "", hash: d };

    });

    const into = choices.length === 1 ? choices[0] : await vscode.window.showQuickPick(choices, { title: `Squash ${info.change_id.slice(0, 8)} into…` });

    if (!into) {

      return;

    }

    question = `Squash "${subject}" into "${into.label}"? The dependency keeps its ChangeId and absorbs these edits.`;

    run = () => repo.oxy.squash(repo.root, change, `#${into.hash.slice(0, 12)}`);

  } else {

    const bookmarks = await repo.oxy.bookmarks(repo.root);

    type Onto = vscode.QuickPickItem & { onto?: string };

    const choices: Onto[] = [

      ...bookmarks.map((b) => ({ label: `$(bookmark) ${b.name}`, description: b.current ? "current bookmark" : "", onto: b.name })),

      { label: "$(edit) Another change, bookmark or tag…" },

    ];

    const pick = await vscode.window.showQuickPick(choices, { title: `Rebase ${info.change_id.slice(0, 8)} onto…` });

    if (!pick) {

      return;

    }

    let onto = pick.onto;

    if (!onto) {

      onto = (await vscode.window.showInputBox({ prompt: "ChangeId prefix, #hash prefix, bookmark or tag" }))?.trim();

      if (!onto) {

        return;

      }

    }

    const target = onto;

    question = `Rebase "${subject}" onto ${target}? The change is re-expressed against that state; its ChangeId stays.`;

    run = () => repo.oxy.rebase(repo.root, change, [target]);

  }

  const verb = action[0].toUpperCase() + action.slice(1);

  if ((await vscode.window.showWarningMessage(question, { modal: true, detail: "Undo reverses it (Oxygen: Undo, or oxy undo)." }, verb)) !== verb) {

    return;

  }

  try {

    const out = await run();

    await repo.refresh();

    HistoryPanel.refresh(repo.root);

    const undo = await vscode.window.showInformationMessage(`Oxygen: ${out.split("\n")[0].replace(/^\* /, "")}`, "Undo");

    if (undo === "Undo") {

      await repo.oxy.undo(repo.root);

      await repo.refresh();

      HistoryPanel.refresh(repo.root);

    }

  } catch (e) {

    showError(e);

  }

}

/** A history-graph context menu command: the webview passes `{ root, hash }`. */

async function historyContext(ctx: { root?: string; hash?: string } | undefined, action: HistoryAction): Promise<void> {

  const repo = ctx?.root ? repositories.get(ctx.root) : undefined;

  if (!repo || !ctx?.hash) {

    return;

  }

  try {

    const info = await repo.oxy.show(repo.root, `#${ctx.hash.slice(0, 12)}`);

    await historyAction(repo, info, action);

  } catch (e) {

    showError(e);

  }

}

// ------------------------------------------------------ commit box (V7)

interface BoxState {

  amend: boolean;

  resolution: boolean;

  signing: string;

  checkedMs: number;

}

const boxes = new Map<string, BoxState>();

let extensionContext: vscode.ExtensionContext | undefined;

function box(repo: Repository): BoxState {

  let b = boxes.get(repo.root);

  if (!b) {

    b = { amend: false, resolution: false, signing: "", checkedMs: 0 };

    boxes.set(repo.root, b);

  }

  return b;

}

/** Placeholder and the Ctrl+Enter action follow amend mode, resolution and signing. */

function updateBox(repo: Repository): void {

  const b = box(repo);

  repo.sourceControl.acceptInputCommand = { command: "oxygen.commit", title: b.amend ? "Amend" : b.resolution ? "Commit resolution" : "Commit", arguments: [repo] };

  repo.sourceControl.inputBox.placeholder = placeholder(b);

}

/** Re-read how commits will be signed, at most every 30 seconds. */

async function refreshSigning(repo: Repository, force = false): Promise<void> {

  const b = box(repo);

  if (!force && Date.now() - b.checkedMs < 30_000) {

    return;

  }

  b.checkedMs = Date.now();

  try {

    b.signing = signingLabel(await repo.oxy.identity(repo.root));

  } catch {

    b.signing = "";

  }

  updateBox(repo);

}

function setAmend(repo: Repository, on: boolean): void {

  box(repo).amend = on;

  void vscode.commands.executeCommand("setContext", "oxygen.amending", [...boxes.values()].some((b) => b.amend));

  updateBox(repo);

}

async function toggleAmend(arg: Repository | vscode.SourceControl | undefined, on: boolean): Promise<void> {

  const repo = repositoryFor(arg);

  if (!repo) {

    return;

  }

  setAmend(repo, on);

  if (on && !repo.sourceControl.inputBox.value.trim()) {

    // Start from the message being amended.

    try {

      const last = (await repo.oxy.log(repo.root, 2)).changes.find((c) => !c.working_copy);

      if (last) {

        repo.sourceControl.inputBox.value = last.message;

      }

    } catch {

      // An empty box keeps the message anyway.

    }

  }

}

function historyOf(repo: Repository): MessageHistory {

  return new MessageHistory(extensionContext?.workspaceState.get<string[]>(`oxygen.messages:${repo.root}`) ?? []);

}

function remember(repo: Repository, message: string): void {

  const h = historyOf(repo);

  h.add(message);

  void extensionContext?.workspaceState.update(`oxygen.messages:${repo.root}`, h.entries);

}

async function messageHistory(arg: Repository | vscode.SourceControl | undefined): Promise<void> {

  const repo = repositoryFor(arg);

  if (!repo) {

    return;

  }

  const entries = historyOf(repo).entries;

  if (entries.length === 0) {

    void vscode.window.showInformationMessage("Oxygen: no messages yet; they are remembered as you commit.");

    return;

  }

  const pick = await vscode.window.showQuickPick(

    entries.map((m) => ({ label: m.split("\n")[0], detail: m.includes("\n") ? m.split("\n").slice(1).join(" ").trim().slice(0, 160) : undefined, message: m })),

    { title: "Previous commit messages", placeHolder: "Put one back in the commit box", matchOnDetail: true },

  );

  if (pick) {

    repo.sourceControl.inputBox.value = pick.message;

  }

}

/**

 * Warn before committing files that still hold conflict markers: those oxy

 * reports (markers left in a conflicted file) and any text file whose lines

 * open or close a conflict. `paths` limits the check to what is committed.

 */

async function markersOk(repo: Repository, paths?: string[]): Promise<boolean> {

  const status = repo.status;

  if (!status) {

    return true;

  }

  const found: { path: string; line?: number }[] = [];

  for (const p of status.paths) {

    if (p.status === "Removed" || (paths && !paths.includes(p.path))) {

      continue;

    }

    if (p.status === "ConflictEdited") {

      found.push({ path: p.path });

      continue;

    }

    try {

      const file = join(repo.root, p.path);

      if ((await stat(file)).size > 4 * 1024 * 1024) {

        continue;

      }

      const text = (await readFile(file)).toString("utf8");

      const lines = conflictMarkerLines(text);

      if (lines.length > 0) {

        found.push({ path: p.path, line: lines[0] });

      }

    } catch {

      // Unreadable or gone: nothing to check.

    }

  }

  if (found.length === 0) {

    return true;

  }

  const list = found.slice(0, 5).map((f) => (f.line ? `${f.path} (line ${f.line})` : f.path)).join(", ") + (found.length > 5 ? ` and ${found.length - 5} more` : "");

  const pick = await vscode.window.showWarningMessage(

    `Conflict markers remain in ${list}. Commit anyway?`,

    { modal: true, detail: "Committing records the marker lines as ordinary text." },

    "Commit anyway",

    `Open ${basename(found[0].path)}`,

  );

  if (pick?.startsWith("Open ")) {

    const doc = await vscode.workspace.openTextDocument(vscode.Uri.file(join(repo.root, found[0].path)));

    const line = Math.max(0, (found[0].line ?? 1) - 1);

    await vscode.window.showTextDocument(doc, { selection: new vscode.Range(line, 0, line, 0) });

    return false;

  }

  return pick === "Commit anyway";

}

async function fileHistory(uri: vscode.Uri | undefined): Promise<void> {

  if (!uri) {

    return;

  }

  const repo = [...repositories.values()].find((r) => r.relativePath(uri) !== undefined);

  const rel = repo?.relativePath(uri);

  if (!repo || !rel) {

    void vscode.window.showInformationMessage("Oxygen: this file is not in an Oxygen repository.");

    return;

  }

  try {

    const log = await repo.oxy.log(repo.root, 200, rel);

    const changes = log.changes.filter((c) => !c.working_copy);

    if (changes.length === 0) {

      void vscode.window.showInformationMessage(`Oxygen: no committed change touches ${rel}.`);

      return;

    }

    const pick = await vscode.window.showQuickPick(

      changes.map((c, i) => ({

        label: `${c.head ? "$(circle-filled)" : "$(circle-outline)"} ${c.message.split("\n")[0]}`,

        description: `${c.change_id.slice(0, 8)} · ${c.author} · ${timeAgo(c.when_ms)}`,

        change: c,

        previous: changes[i + 1],

      })),

      { placeHolder: `${changes.length} change${changes.length === 1 ? "" : "s"} touched ${rel}; pick one to compare with the version before it`, matchOnDescription: true },

    );

    if (!pick) {

      return;

    }

    const after = oxyUriFor(repo.root, rel, pick.change.hash);

    if (pick.previous) {

      const before = oxyUriFor(repo.root, rel, pick.previous.hash);

      await vscode.commands.executeCommand("vscode.diff", before, after, `${basename(rel)} (${pick.previous.change_id.slice(0, 8)} ↔ ${pick.change.change_id.slice(0, 8)})`);

    } else {

      await vscode.commands.executeCommand("vscode.open", after);

    }

  } catch (e) {

    showError(e);

  }

}

function oxyUriFor(root: string, rel: string, hash: string): vscode.Uri {

  return oxyUri(root, rel, `#${hash.slice(0, 12)}`);

}

// ---------------------------------------------------------------- bookmarks

async function switchBookmark(arg: Repository | vscode.SourceControl | undefined): Promise<void> {

  const repo = repositoryFor(arg);

  if (!repo) {

    return;

  }

  let bookmarks;

  try {

    bookmarks = await repo.oxy.bookmarks(repo.root);

  } catch (e) {

    showError(e);

    return;

  }

  type Item = vscode.QuickPickItem & { action: "switch" | "create" | "merge" | "delete"; name?: string };

  const items: Item[] = bookmarks.map((b) => ({

    label: `${b.current ? "$(circle-filled)" : "$(bookmark)"} ${b.name}`,

    description: `${b.heads.length} head${b.heads.length === 1 ? "" : "s"}${b.ahead ? ` $(arrow-up)${b.ahead}` : ""}${b.behind ? ` $(arrow-down)${b.behind}` : ""}`,

    detail: b.current ? "current bookmark" : undefined,

    action: "switch",

    name: b.name,

  }));

  items.push(

    { label: "$(add) Create bookmark…", action: "create", alwaysShow: true },

    { label: "$(git-merge) Merge a bookmark into the current one…", action: "merge", alwaysShow: true },

    { label: "$(trash) Delete a bookmark…", action: "delete", alwaysShow: true },

  );

  const pick = await vscode.window.showQuickPick(items, { placeHolder: "Switch to a bookmark" });

  if (!pick) {

    return;

  }

  switch (pick.action) {

    case "create":

      return createBookmark(repo);

    case "merge":

      return mergeBookmark(repo);

    case "delete":

      return deleteBookmark(repo);

    case "switch":

      if (pick.name && !bookmarks.find((b) => b.name === pick.name)?.current) {

        await doSwitch(repo, pick.name);

      }

  }

}

async function doSwitch(repo: Repository, name: string): Promise<void> {

  try {

    await vscode.window.withProgress({ location: vscode.ProgressLocation.SourceControl, title: `Switching to ${name}` }, () => repo.oxy.bookmarkSwitch(repo.root, name));

  } catch (e) {

    if (e instanceof OxyError && e.message.includes("has changes")) {

      const pick = await vscode.window.showWarningMessage(`The working copy has uncommitted changes. Switching to ${name} would discard them.`, { modal: true }, "Discard and switch");

      if (pick === "Discard and switch") {

        try {

          await repo.oxy.bookmarkSwitch(repo.root, name, true);

        } catch (e2) {

          showError(e2);

        }

      }

    } else {

      showError(e);

    }

  }

  await repo.refresh();

}

async function createBookmark(arg: Repository | vscode.SourceControl | undefined): Promise<void> {

  const repo = repositoryFor(arg);

  if (!repo) {

    return;

  }

  const name = await vscode.window.showInputBox({

    prompt: "New bookmark name (created at the working copy's base)",

    validateInput: (v) => (!v.trim() || v.startsWith("-") || v.includes("..") || v.includes("//") || /[\s@{]/.test(v) ? "Not a valid bookmark name" : undefined),

  });

  if (!name) {

    return;

  }

  try {

    await repo.oxy.bookmarkCreate(repo.root, name.trim());

    const pick = await vscode.window.showInformationMessage(`Oxygen: created bookmark ${name}.`, "Switch to it");

    if (pick) {

      await doSwitch(repo, name.trim());

    }

    await repo.refresh();

  } catch (e) {

    showError(e);

  }

}

async function pickBookmark(repo: Repository, placeHolder: string, excludeCurrent: boolean): Promise<string | undefined> {

  const bookmarks = await repo.oxy.bookmarks(repo.root);

  const items = bookmarks.filter((b) => !excludeCurrent || !b.current).map((b) => ({ label: b.name, description: `${b.heads.length} head${b.heads.length === 1 ? "" : "s"}` }));

  if (items.length === 0) {

    void vscode.window.showInformationMessage("Oxygen: no other bookmarks.");

    return undefined;

  }

  return (await vscode.window.showQuickPick(items, { placeHolder }))?.label;

}

async function mergeBookmark(arg: Repository | vscode.SourceControl | undefined): Promise<void> {

  const repo = repositoryFor(arg);

  if (!repo) {

    return;

  }

  try {

    const name = await pickBookmark(repo, `Merge into ${repo.currentBookmark?.name ?? "the current bookmark"}`, true);

    if (!name) {

      return;

    }

    const out = await vscode.window.withProgress({ location: vscode.ProgressLocation.SourceControl, title: `Merging ${name}` }, () => repo.oxy.merge(repo.root, name));

    await repo.refresh();

    if (repo.status?.conflicted) {

      void vscode.window.showWarningMessage(`Oxygen: merged ${name}; the result has conflicts to resolve.`);

    } else {

      vscode.window.setStatusBarMessage(`$(git-merge) ${out.split("\n")[0]}`, 5000);

    }

  } catch (e) {

    showError(e);

  }

}

async function deleteBookmark(arg: Repository | vscode.SourceControl | undefined): Promise<void> {

  const repo = repositoryFor(arg);

  if (!repo) {

    return;

  }

  try {

    const name = await pickBookmark(repo, "Delete which bookmark? Its changes stay.", true);

    if (!name) {

      return;

    }

    const pick = await vscode.window.showWarningMessage(`Delete bookmark ${name}?`, { modal: true }, "Delete");

    if (pick !== "Delete") {

      return;

    }

    await repo.oxy.bookmarkDelete(repo.root, name);

    await repo.refresh();

  } catch (e) {

    showError(e);

  }

}

// ---------------------------------------------------------------- sync

async function pickRemote(repo: Repository): Promise<string | undefined> {

  const remotes = await repo.oxy.remotes(repo.root);

  if (remotes.length === 0) {

    void vscode.window.showErrorMessage("Oxygen: this repository has no remotes. Add one with oxy remote add <name> <url>.");

    return undefined;

  }

  if (remotes.length === 1) {

    return remotes[0].name;

  }

  return (await vscode.window.showQuickPick(remotes.map((r) => ({ label: r.name, description: r.url })), { placeHolder: "Remote" }))?.label;

}

async function fetch(arg: Repository | vscode.SourceControl | undefined): Promise<void> {

  const repo = repositoryFor(arg);

  if (!repo) {

    return;

  }

  try {

    const remote = await pickRemote(repo);

    if (!remote) {

      return;

    }

    const info = await vscode.window.withProgress({ location: vscode.ProgressLocation.SourceControl, title: `Fetching from ${remote}` }, () => repo.oxy.fetch(repo.root, remote));

    await repo.refresh();

    const fresh = info.refs.filter((r) => r.new > 0);

    const summary = fresh.length ? fresh.map((r) => `${r.name}: ${r.new} new`).join(", ") : "nothing new";

    vscode.window.setStatusBarMessage(`$(cloud-download) ${remote}: ${summary}`, 5000);

    if (info.unverified) {

      void vscode.window.showWarningMessage(`Oxygen: ${remote} has no trust policy; nothing fetched from it was verified.`);

    }

  } catch (e) {

    showError(e);

  }

}

async function pull(arg: Repository | vscode.SourceControl | undefined): Promise<void> {

  const repo = repositoryFor(arg);

  if (!repo) {

    return;

  }

  try {

    const remote = await pickRemote(repo);

    if (!remote) {

      return;

    }

    const info = await vscode.window.withProgress({ location: vscode.ProgressLocation.SourceControl, title: `Pulling from ${remote}` }, () => repo.oxy.pull(repo.root, remote));

    await repo.refresh();

    if (!info.changed) {

      vscode.window.setStatusBarMessage("$(check) Already up to date", 4000);

    } else if (info.conflicted) {

      void vscode.window.showWarningMessage("Oxygen: pulled; the result has conflicts to resolve.");

    } else if (!info.checked_out) {

      void vscode.window.showInformationMessage("Oxygen: pulled; the working copy was not updated because it has changes. Check out when ready.");

    } else {

      vscode.window.setStatusBarMessage(`$(cloud-download) Pulled from ${remote}`, 4000);

    }

  } catch (e) {

    showError(e);

  }

}

async function push(arg: Repository | vscode.SourceControl | undefined, chooseBookmark: boolean): Promise<void> {

  const repo = repositoryFor(arg);

  if (!repo) {

    return;

  }

  try {

    const remote = await pickRemote(repo);

    if (!remote) {

      return;

    }

    let bookmark: string | undefined;

    if (chooseBookmark) {

      bookmark = await pickBookmark(repo, "Push which bookmark?", false);

      if (!bookmark) {

        return;

      }

    }

    if (vscode.workspace.getConfiguration("oxygen").get<boolean>("confirmSync", true)) {

      const pick = await vscode.window.showInformationMessage(`Push ${bookmark ?? repo.currentBookmark?.name ?? "the current bookmark"} to ${remote}?`, { modal: false }, "Push", "Always push without asking");

      if (!pick) {

        return;

      }

      if (pick === "Always push without asking") {

        await vscode.workspace.getConfiguration("oxygen").update("confirmSync", false, vscode.ConfigurationTarget.Global);

      }

    }

    const results = await vscode.window.withProgress({ location: vscode.ProgressLocation.SourceControl, title: `Pushing to ${remote}` }, () => repo.oxy.push(repo.root, remote, bookmark));

    await repo.refresh();

    const rejected = results.filter((r) => !r.ok);

    if (rejected.length === 0) {

      vscode.window.setStatusBarMessage(`$(cloud-upload) Pushed to ${remote}`, 4000);

      return;

    }

    const reason = rejected.map((r) => `${r.name}: ${r.reason}`).join("; ");

    const pick = await vscode.window.showErrorMessage(`Oxygen: push rejected. ${reason}`, "Pull", "Show Output");

    if (pick === "Pull") {

      await pull(repo);

    } else if (pick === "Show Output") {

      output.show();

    }

  } catch (e) {

    if (e instanceof OxyError && e.message.includes("pull first")) {

      const pick = await vscode.window.showWarningMessage(`Oxygen: ${e.message}`, "Pull");

      if (pick === "Pull") {

        await pull(repo);

      }

      return;

    }

    showError(e);

  }

}

async function sync(arg: Repository | vscode.SourceControl | undefined): Promise<void> {

  const repo = repositoryFor(arg);

  if (!repo) {

    return;

  }

  await pull(repo);

  if (repo.status?.conflicted) {

    return;

  }

  if ((repo.currentBookmark?.ahead ?? 0) > 0) {

    await push(repo, false);

  }

}

/** The commit message from the input box, else a prompt. */

async function askMessage(repo: Repository, prompt: string): Promise<string | undefined> {

  const fromBox = repo.sourceControl.inputBox.value.trim();

  if (fromBox) {

    return fromBox;

  }

  return (await vscode.window.showInputBox({ prompt, placeHolder: "Commit message" }))?.trim() || undefined;

}

async function showLog(): Promise<void> {

  const repo = repositoryFor(undefined);

  if (!repo) {

    return;

  }

  try {

    const log = await repo.oxy.log(repo.root, 50);

    const items = log.changes

      .filter((c) => !c.working_copy)

      .map((c) => ({

        label: `${c.head ? "$(circle-filled)" : "$(circle-outline)"} ${c.message.split("\n")[0]}`,

        description: `${c.change_id.slice(0, 8)} · ${c.author}`,

        detail: `${new Date(c.when_ms).toLocaleString()} · ${c.signature?.status ?? "unsigned"}${c.signature?.revoked ? " (key revoked)" : ""}`,

        change: c,

      }));

    const pick = await vscode.window.showQuickPick(items, { placeHolder: `${log.bookmark}: ${log.total - 1} changes`, matchOnDescription: true, matchOnDetail: true });

    if (pick) {

      const doc = await vscode.workspace.openTextDocument({ content: pick.change.message, language: "markdown" });

      await vscode.window.showTextDocument(doc, { preview: true });

    }

  } catch (e) {

    showError(e);

  }

}

function showError(e: unknown): void {

  const message = e instanceof OxyError ? e.message : String(e);

  void vscode.window.showErrorMessage(`Oxygen: ${message}`, "Show Output").then((pick) => pick && output.show());

}