// Activation: sign in, find the Oxygen extension's API, register the

// remote provider, wire the views, the review controller and the commands.

import * as vscode from "vscode";

import { HubAuth } from "./auth";

import { ChecksBar } from "./checks";

import { ProposalContentProvider, SCHEME, openAllChanges, openFileDiff, refOf } from "./diff";

import { FlowLogs, FlowProvider, JobNode, LOG_SCHEME, RunNode, openLog, useLogs } from "./flow";

import { hubUrl } from "./hub";

import { InboxBar } from "./inbox";

import { AssetNode, draftRelease, ReleaseNode, ReleasesProvider, saveAsset, showTrust } from "./releases";

import { DROP_SCHEME } from "./dropkit";

import { DropFileSystem, DropsProvider, registerDropCommands, shareFiles, shareSelection } from "./drops";

import { newRepository } from "./newrepo";

import { HubTests } from "./tests";

import { DiffusionPinNode, DiffusionProvider, diffusionTab, pinUrl } from "./diffusion";

import { ReferenceCompletions, ReferenceHovers, ReferenceIndex, SELECTOR } from "./references";

import { annotateTodo, issueBody, todoTitle } from "./refs";

import { IssueNode, IssuesProvider, showIssue } from "./issues";

import type { OxygenAPI } from "./oxygenapi";

import { HubRepo, ProposalFileNode, ProposalNode, ProposalsProvider, showDetail } from "./proposals";

import { makeProvider } from "./provider";

import { ReviewController } from "./review";

let auth: HubAuth;

let oxygen: OxygenAPI | undefined;

let proposals: ProposalsProvider;

let issues: IssuesProvider;

let review: ReviewController;

let bar: ChecksBar;

let content: ProposalContentProvider;

let inbox: InboxBar;

let references: ReferenceIndex;

let releases: ReleasesProvider;

let diffusion: DiffusionProvider;

let flow: FlowProvider;

let drops: DropsProvider;

let tests: HubTests;

export async function activate(context: vscode.ExtensionContext): Promise<void> {

  auth = new HubAuth(context.secrets);

  await auth.load();

  context.subscriptions.push(auth);

  // Oxygen VCS may be missing or fail to start (two copies of it installed

  // at once): OxygenHub still starts, so signing in and the hub views work.

  const ext = vscode.extensions.getExtension<OxygenAPI>("oxygenhub.oxygen-vscode");

  try {

    oxygen = ext ? ((await ext.activate()) as OxygenAPI | undefined) : undefined;

  } catch {

    oxygen = undefined;

  }

  if (!oxygen) {

    void vscode.window.showWarningMessage("OxygenHub: the Oxygen VCS extension is not available; install Oxygen VCS (oxygenhub.oxygen-vscode) 0.17.1 or later, and only one copy of it.");

  } else {

    context.subscriptions.push(oxygen.registerRemoteProvider(makeProvider({ bases: () => auth.bases() })));

    context.subscriptions.push(oxygen.onDidChangeRepositories(() => refreshAll()));

  }

  proposals = new ProposalsProvider(() => oxygen, auth);

  issues = new IssuesProvider(() => proposals.repos(), auth);

  review = new ReviewController(auth);

  bar = new ChecksBar(auth, () => proposals.repos());

  inbox = new InboxBar(auth, async (t) => {

    const repo = (await proposals.repos()).find((r) => r.base === t.base && r.owner === t.owner && r.name === t.name);

    if (!repo) {

      return false;

    }

    const client = auth.clientFor(repo.base);

    if (t.kind === "proposal") {

      const [p, checks] = await Promise.all([client.proposal(repo.owner, repo.name, t.number), client.proposalChecks(repo.owner, repo.name, t.number).catch(() => [])]);

      showDetail(repo, p, checks);

    } else {

      await showIssue(auth, repo, await client.issue(repo.owner, repo.name, t.number));

    }

    return true;

  });

  context.subscriptions.push(inbox);

  releases = new ReleasesProvider(() => proposals.repos(), auth);

  context.subscriptions.push(vscode.window.registerTreeDataProvider("oxygenhub.releases", releases));

  diffusion = new DiffusionProvider(() => proposals.repos(), auth);

  context.subscriptions.push(

    vscode.window.registerTreeDataProvider("oxygenhub.diffusion", diffusion),

    // A bump on this repository opens beside the code, as any proposal does;

    // the rest open on the hub.

    vscode.commands.registerCommand("oxygenhub.openDiffusionPin", async (node: DiffusionPinNode) => {

      const bump = node.pin.bump;

      if (node.side === "takes" && bump !== null && bump !== undefined) {

        try {

          const client = auth.clientFor(node.repo.base);

          const [p, checks] = await Promise.all([client.proposal(node.repo.owner, node.repo.name, bump), client.proposalChecks(node.repo.owner, node.repo.name, bump).catch(() => [])]);

          showDetail(node.repo, p, checks);

          return;

        } catch (e) {

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

        }

      }

      void vscode.env.openExternal(vscode.Uri.parse(pinUrl(node)));

    }),

    vscode.commands.registerCommand("oxygenhub.openDiffusionOnHub", (node?: DiffusionPinNode | { kind: "repo"; repo: HubRepo }) => {

      if (node) {

        void vscode.env.openExternal(vscode.Uri.parse(node.kind === "pin" ? pinUrl(node) : diffusionTab(node.repo)));

      }

    }),

  );

  flow = new FlowProvider(() => proposals.repos(), auth);

  const flowLogs = new FlowLogs(auth);

  useLogs(flowLogs);

  context.subscriptions.push(

    flow,

    flowLogs,

    vscode.window.registerTreeDataProvider("oxygenhub.flow", flow),

    vscode.workspace.registerTextDocumentContentProvider(LOG_SCHEME, flowLogs),

    vscode.commands.registerCommand("oxygenhub.flowRefresh", () => flow.refresh()),

    vscode.commands.registerCommand("oxygenhub.runPipeline", (node?: { repo?: HubRepo }) => flow.start(node?.repo)),

    vscode.commands.registerCommand("oxygenhub.rerunFlow", (node: RunNode) => flow.rerun(node)),

    vscode.commands.registerCommand("oxygenhub.flowLog", (node: JobNode) => openLog(node.repo, node.run, node.job)),

    vscode.commands.registerCommand("oxygenhub.openFlowRun", (node: RunNode) => vscode.env.openExternal(vscode.Uri.parse(node.run.url))),

    vscode.commands.registerCommand("oxygenhub.flowRecent", (repo?: HubRepo) => flow.recent(repo)),

    vscode.commands.registerCommand("oxygenhub.approveJob", (node: JobNode) => flow.decide(node, true)),

    vscode.commands.registerCommand("oxygenhub.rejectJob", (node: JobNode) => flow.decide(node, false)),

    vscode.commands.registerCommand("oxygenhub.expediteRun", (node: RunNode) => flow.expedite(node)),

    vscode.commands.registerCommand("oxygenhub.cancelRun", (node: RunNode) => flow.cancel(node)),

    vscode.commands.registerCommand("oxygenhub.jobReports", (node: JobNode) => flow.reports(node)),

  );

  drops = new DropsProvider(auth);

  context.subscriptions.push(

    vscode.window.registerTreeDataProvider("oxygenhub.drops", drops),

    vscode.workspace.registerFileSystemProvider(DROP_SCHEME, new DropFileSystem(auth, () => drops.refresh()), { isCaseSensitive: true }),

    ...registerDropCommands(auth, drops),

    vscode.commands.registerCommand("oxygenhub.shareSelectionAsDrop", (uri?: vscode.Uri) => shareSelection(auth, drops, uri instanceof vscode.Uri ? uri : undefined)),

    vscode.commands.registerCommand("oxygenhub.shareFilesAsDrop", (uri?: vscode.Uri, uris?: vscode.Uri[]) => shareFiles(auth, drops, uri instanceof vscode.Uri ? uri : undefined, uris)),

  );

  tests = new HubTests(auth, () => proposals.repos());

  context.subscriptions.push(

    tests,

    vscode.commands.registerCommand("oxygenhub.releaseTrust", (node: ReleaseNode) => showTrust(auth, node).catch((e: Error) => vscode.window.showErrorMessage(`OxygenHub: ${e.message}`))),

    vscode.commands.registerCommand("oxygenhub.saveAsset", (node: AssetNode) => saveAsset(auth, node).catch((e: Error) => vscode.window.showErrorMessage(`OxygenHub: ${e.message}`))),

    vscode.commands.registerCommand("oxygenhub.newRepository", () => newRepository(auth)),

    vscode.commands.registerCommand("oxygenhub.markReady", (...args: unknown[]) => withProposal(args, (repo, number) => setDraft(repo, number, false))),

    vscode.commands.registerCommand("oxygenhub.convertToDraft", (...args: unknown[]) => withProposal(args, (repo, number) => setDraft(repo, number, true))),

    vscode.commands.registerCommand("oxygenhub.landable", () => landable()),

  );

  references = new ReferenceIndex(auth, () => proposals.repos());

  context.subscriptions.push(

    vscode.languages.registerCompletionItemProvider(SELECTOR, new ReferenceCompletions(references), "#", "@"),

    vscode.languages.registerHoverProvider(SELECTOR, new ReferenceHovers(references)),

  );

  content = new ProposalContentProvider(auth);

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

  context.subscriptions.push(vscode.window.registerTreeDataProvider("oxygenhub.proposals", proposals), vscode.window.registerTreeDataProvider("oxygenhub.issues", issues), review, bar);

  context.subscriptions.push(auth.onDidChange(() => refreshAll()));

  context.subscriptions.push(

    vscode.commands.registerCommand("oxygenhub.signIn", async () => {

      const repos = oxygen ? await guessHubs() : [];

      await auth.signIn(repos[0]);

      refreshAll();

    }),

    vscode.commands.registerCommand("oxygenhub.signOut", async () => {

      const pick = await vscode.window.showQuickPick(auth.all().map((s) => s.base), { placeHolder: "Sign out of" });

      if (pick) {

        await auth.removeSession(pick);

        refreshAll();

      }

    }),

    vscode.commands.registerCommand("oxygenhub.refresh", () => refreshAll()),

    vscode.commands.registerCommand("oxygenhub.inbox", () => inbox.show()),

    vscode.commands.registerCommand("oxygenhub.draftRelease", async (node?: { repo?: HubRepo }) => {

      const repos = await proposals.repos();

      const repo = node?.repo ?? (repos.length === 1 ? repos[0] : (await vscode.window.showQuickPick(repos.map((r) => ({ label: `${r.owner}/${r.name}`, r })), { placeHolder: "Repository" }))?.r);

      if (!repo) {

        return;

      }

      try {

        const r = await draftRelease(auth, repo);

        if (r) {

          releases.refresh();

          const open = await vscode.window.showInformationMessage(`OxygenHub: released ${r.tag}.`, "Open on Hub");

          if (open) {

            void vscode.env.openExternal(vscode.Uri.parse(r.url));

          }

        }

      } catch (e) {

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

      }

    }),

    vscode.commands.registerCommand("oxygenhub.openProposal", async (node?: ProposalNode) => {

      const n = node ?? (await pickProposal());

      if (!n) {

        return;

      }

      const checks = await auth.clientFor(n.repo.base).proposalChecks(n.repo.owner, n.repo.name, n.p.number).catch(() => []);

      showDetail(n.repo, n.p, checks);

    }),

    vscode.commands.registerCommand("oxygenhub.openOnHub", (node?: ProposalNode | IssueNode) => {

      if (!node) {

        return;

      }

      const target = node.kind === "proposal" ? { kind: "proposal", number: node.p.number } : { kind: "issue", number: node.i.number };

      void vscode.env.openExternal(vscode.Uri.parse(hubUrl(node.repo.base, node.repo.owner, node.repo.name, target)));

    }),

    vscode.commands.registerCommand("oxygenhub.openProposalFile", async (node: ProposalFileNode) => {

      await openFileDiff(node.repo, node.p.number, node.f);

      await review.loadDiff(node.repo, node.p.number).catch(() => undefined);

    }),

    vscode.commands.registerCommand("oxygenhub.openProposalChanges", (...args: unknown[]) =>

      withProposal(args, async (repo, number) => {

        try {

          const client = auth.clientFor(repo.base);

          const [p, files] = await Promise.all([client.proposal(repo.owner, repo.name, number), client.proposalFiles(repo.owner, repo.name, number)]);

          await openAllChanges(repo, p, files);

          await review.loadDiff(repo, number);

        } catch (e) {

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

        }

      }),

    ),

    vscode.commands.registerCommand("oxygenhub.checkoutProposal", (...args: unknown[]) => withProposal(args, checkout)),

    vscode.commands.registerCommand("oxygenhub.review", (...args: unknown[]) => withProposal(args, reviewProposal)),

    vscode.commands.registerCommand("oxygenhub.sealApproval", (...args: unknown[]) => withProposal(args, (repo, number) => runInTerminal(repo, `oxy seal --proposal ${hubUrl(repo.base, repo.owner, repo.name, { kind: "proposal", number })}`))),

    vscode.commands.registerCommand("oxygenhub.land", (...args: unknown[]) => withProposal(args, (repo, number) => runInTerminal(repo, `oxy proposal land ${hubUrl(repo.base, repo.owner, repo.name, { kind: "proposal", number })}`))),

    vscode.commands.registerCommand("oxygenhub.closeProposal", (...args: unknown[]) =>

      withProposal(args, async (repo, number) => {

        void vscode.env.openExternal(vscode.Uri.parse(hubUrl(repo.base, repo.owner, repo.name, { kind: "proposal", number })));

      }),

    ),

    vscode.commands.registerCommand("oxygenhub.createProposal", () => createProposal()),

    vscode.commands.registerCommand("oxygenhub.newIssue", () => newIssue()),

    vscode.commands.registerCommand("oxygenhub.issueFromSelection", () => issueFromSelection()),

    vscode.commands.registerCommand("oxygenhub.openIssue", async (node?: IssueNode) => node && showIssue(auth, node.repo, node.i)),

    vscode.commands.registerCommand("oxygenhub.commentIssue", (...args: unknown[]) =>

      withIssue(args, async (repo, number) => {

        const body = await vscode.window.showInputBox({ prompt: `Comment on #${number}` });

        if (body) {

          await auth.clientFor(repo.base).commentIssue(repo.owner, repo.name, number, body);

          issues.refresh();

        }

      }),

    ),

    vscode.commands.registerCommand("oxygenhub.closeIssue", (...args: unknown[]) => withIssue(args, async (repo, number) => (await auth.clientFor(repo.base).setIssueState(repo.owner, repo.name, number, "closed"), issues.refresh()))),

    vscode.commands.registerCommand("oxygenhub.reopenIssue", (...args: unknown[]) => withIssue(args, async (repo, number) => (await auth.clientFor(repo.base).setIssueState(repo.owner, repo.name, number, "open"), issues.refresh()))),

    vscode.commands.registerCommand("oxygenhub.assignMe", (...args: unknown[]) =>

      withIssue(args, async (repo, number) => {

        void vscode.window.showInformationMessage(`OxygenHub: assigning is on the hub for now: ${hubUrl(repo.base, repo.owner, repo.name, { kind: "issue", number })}`);

      }),

    ),

    vscode.commands.registerCommand("oxygenhub.reply", (reply: vscode.CommentReply) => review.reply(reply)),

    vscode.commands.registerCommand("oxygenhub.newThread", (reply: vscode.CommentReply) => review.reply(reply)),

    vscode.commands.registerCommand("oxygenhub.resolveThread", (thread: vscode.CommentThread) => {

      thread.state = thread.state === vscode.CommentThreadState.Resolved ? vscode.CommentThreadState.Unresolved : vscode.CommentThreadState.Resolved;

    }),

  );

  bar.start();

  inbox.start();

  void tests.load();

}

function refreshAll(): void {

  proposals.refresh();

  references.clear();

  refreshOpenDiffs();

  issues.refresh();

  releases.refresh();

  diffusion.refresh();

  drops.refresh();

  void tests.load();

  void flow.refresh();

  void bar.refresh();

  void inbox.refresh();

}

/** Reload the sides of open proposal diffs, which may have gained changes. */

function refreshOpenDiffs(): void {

  const seen = new Set<string>();

  for (const doc of vscode.workspace.textDocuments) {

    const r = refOf(doc.uri);

    const key = r && `${r.base}/${r.owner}/${r.name}#${r.number}`;

    if (r && key && !seen.has(key)) {

      seen.add(key);

      content.refresh(r.base, r.owner, r.name, r.number);

    }

  }

}

async function guessHubs(): Promise<string[]> {

  const out: string[] = [];

  for (const r of oxygen?.repositories ?? []) {

    for (const remote of await r.remotes().catch(() => [])) {

      const m = /^(https?:\/\/[^/]+)\/[^/]+\/[^/]+\/?$/.exec(remote.url);

      if (m && remote.ca) {

        auth.setCa(m[1], remote.ca);

      }

      if (m && !out.includes(m[1])) {

        out.push(m[1]);

      }

    }

  }

  return out;

}

async function pickProposal(): Promise<ProposalNode | undefined> {

  const items: { label: string; description: string; node: ProposalNode }[] = [];

  for (const repo of await proposals.repos()) {

    for (const p of await proposals.proposalsOf(repo).catch(() => [])) {

      items.push({ label: `#${p.number} ${p.title}`, description: `${repo.owner}/${repo.name} · ${p.author} → ${p.target}`, node: { kind: "proposal", repo, p } });

    }

  }

  return (await vscode.window.showQuickPick(items, { placeHolder: "Proposal" }))?.node;

}

/** Commands take a tree node, or the webview's `[base, owner, name, number]`. */

async function withProposal(args: unknown[], f: (repo: HubRepo, number: number) => Promise<void>): Promise<void> {

  const a = args[0];

  if (a && typeof a === "object" && (a as ProposalNode).kind === "proposal") {

    const n = a as ProposalNode;

    return f(n.repo, n.p.number);

  }

  if (Array.isArray(a) && a.length === 4) {

    const [base, owner, name, number] = a as [string, string, string, number];

    const repo = (await proposals.repos()).find((r) => r.base === base && r.owner === owner && r.name === name);

    if (repo) {

      return f(repo, number);

    }

  }

  const n = await pickProposal();

  if (n) {

    return f(n.repo, n.p.number);

  }

}

async function withIssue(args: unknown[], f: (repo: HubRepo, number: number) => Promise<void>): Promise<void> {

  const a = args[0];

  if (a && typeof a === "object" && (a as IssueNode).kind === "issue") {

    const n = a as IssueNode;

    return f(n.repo, n.i.number);

  }

  if (Array.isArray(a) && a.length === 4) {

    const [base, owner, name, number] = a as [string, string, string, number];

    const repo = (await proposals.repos()).find((r) => r.base === base && r.owner === owner && r.name === name);

    if (repo) {

      return f(repo, number);

    }

  }

}

function runInTerminal(repo: HubRepo, command: string): Promise<void> {

  const t = vscode.window.createTerminal({ name: "OxygenHub", cwd: repo.handle.root });

  t.show();

  t.sendText(command);

  return Promise.resolve();

}

/** Fetch the proposal's changes and switch to a local bookmark at its projected heads (spec §5). */

async function checkout(repo: HubRepo, number: number): Promise<void> {

  const p = await auth.clientFor(repo.base).proposal(repo.owner, repo.name, number);

  const prefix = vscode.workspace.getConfiguration("oxygenhub").get<string>("proposalBookmarkPrefix") ?? "proposal/";

  const bookmark = `${prefix}${number}`;

  try {

    await repo.handle.json(["fetch", repo.remote, "--json"]);

    const existing = repo.handle.bookmarks.some((b) => b.name === bookmark);

    if (!existing) {

      await repo.handle.json(["bookmark", "create", bookmark, ...p.projected_heads, "--json"]).catch(() => repo.handle.json(["bookmark", "create", bookmark, "--json"]));

    }

    await repo.handle.json(["bookmark", "set", bookmark, ...p.projected_heads, "--json"]).catch(() => undefined);

    await repo.handle.json(["bookmark", "switch", bookmark, "--json"]);

    await repo.handle.refresh();

    await review.load(repo, number);

    void vscode.window.showInformationMessage(`OxygenHub: checked out #${number} as ${bookmark}; review threads are in place.`);

  } catch (e) {

    void vscode.window.showErrorMessage(`OxygenHub: could not check out #${number}: ${(e as Error).message}`);

  }

}

async function reviewProposal(repo: HubRepo, number: number): Promise<void> {

  const verdict = await vscode.window.showQuickPick(

    [

      { label: "Comment", value: "comment" as const },

      { label: "Approve", value: "approve" as const, description: "then seal it with oxy so it counts" },

      { label: "Request changes", value: "changes" as const },

    ],

    { placeHolder: `Review #${number}` },

  );

  if (!verdict) {

    return;

  }

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

  try {

    await auth.clientFor(repo.base).review(repo.owner, repo.name, number, verdict.value, body);

  } catch (e) {

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

    return;

  }

  proposals.refresh();

  if (verdict.value === "approve") {

    const pick = await vscode.window.showInformationMessage("Approval recorded. Seal it with your key so it counts?", "Seal now");

    if (pick === "Seal now") {

      await runInTerminal(repo, `oxy seal --proposal ${hubUrl(repo.base, repo.owner, repo.name, { kind: "proposal", number })}`);

    }

  }

}

async function createProposal(): Promise<void> {

  const repos = await proposals.repos();

  const repo = repos.length === 1 ? repos[0] : (await vscode.window.showQuickPick(repos.map((r) => ({ label: `${r.owner}/${r.name}`, r })), { placeHolder: "Repository" }))?.r;

  if (!repo) {

    return;

  }

  const source = repo.handle.currentBookmark;

  if (!source) {

    void vscode.window.showWarningMessage("OxygenHub: no current bookmark.");

    return;

  }

  const remoteBookmarks = await auth.clientFor(repo.base).bookmarks(repo.owner, repo.name).catch(() => []);

  const target = await vscode.window.showQuickPick(remoteBookmarks.filter((b) => b.name !== source).map((b) => b.name), { placeHolder: `Propose ${source} into…` });

  if (!target) {

    return;

  }

  const title = await vscode.window.showInputBox({ prompt: "Title", value: source });

  if (!title) {

    return;

  }

  try {

    await repo.handle.json(["push", repo.remote, "--bookmark", source, "--json"]).catch(() => undefined);

    const p = await auth.clientFor(repo.base).createProposal(repo.owner, repo.name, { title, body: "", target, source, draft: false });

    proposals.refresh();

    void vscode.env.openExternal(vscode.Uri.parse(p.url));

  } catch (e) {

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

  }

}

async function newIssue(): Promise<void> {

  const repos = await proposals.repos();

  const repo = repos.length === 1 ? repos[0] : (await vscode.window.showQuickPick(repos.map((r) => ({ label: `${r.owner}/${r.name}`, r })), { placeHolder: "Repository" }))?.r;

  if (!repo) {

    return;

  }

  const title = await vscode.window.showInputBox({ prompt: "Issue title" });

  if (!title) {

    return;

  }

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

  try {

    const i = await auth.clientFor(repo.base).createIssue(repo.owner, repo.name, title, body);

    issues.refresh();

    void vscode.window.showInformationMessage(`OxygenHub: opened #${i.number}.`);

  } catch (e) {

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

  }

}

/**

 * An issue from the editor (spec §8.1): the selection, or the current line,

 * quoted under a permalink to it on the hub. A TODO line suggests the title

 * and afterwards records the issue's number.

 */

async function issueFromSelection(): Promise<void> {

  const editor = vscode.window.activeTextEditor;

  if (!editor || editor.document.uri.scheme !== "file") {

    void vscode.window.showWarningMessage("OxygenHub: open a file of the repository first.");

    return;

  }

  const doc = editor.document;

  const file = doc.uri.fsPath;

  const repo = (await proposals.repos()).filter((r) => file.startsWith(r.handle.root + "/") || file.startsWith(r.handle.root + "\\")).sort((a, b) => b.handle.root.length - a.handle.root.length)[0];

  if (!repo) {

    void vscode.window.showWarningMessage("OxygenHub: this file is not in a repository with a hub remote.");

    return;

  }

  const sel = editor.selection;

  const startLine = sel.start.line;

  const endLine = sel.isEmpty ? sel.start.line : sel.end.character === 0 && sel.end.line > sel.start.line ? sel.end.line - 1 : sel.end.line;

  const code = doc.getText(new vscode.Range(startLine, 0, endLine, doc.lineAt(endLine).text.length));

  const todoLine = [...Array(endLine - startLine + 1).keys()].map((i) => startLine + i).find((l) => todoTitle(doc.lineAt(l).text) !== undefined);

  const title = await vscode.window.showInputBox({ prompt: "Issue title", value: todoLine !== undefined ? todoTitle(doc.lineAt(todoLine).text) : "" });

  if (!title) {

    return;

  }

  // Pin the link to the head when the bookmark has one; otherwise follow the bookmark.

  const bookmark = repo.handle.bookmarks.find((b) => b.name === repo.handle.currentBookmark);

  const pinned = bookmark?.heads.length === 1 && !doc.isDirty;

  const reference = pinned ? bookmark!.heads[0] : (repo.handle.currentBookmark ?? "main");

  const path = file.slice(repo.handle.root.length + 1).split("\\").join("/");

  const permalink = hubUrl(repo.base, repo.owner, repo.name, { kind: "file", reference, path, line: startLine + 1, endLine: endLine + 1 });

  const body = issueBody({ permalink, path, startLine: startLine + 1, endLine: endLine + 1, language: doc.languageId === "plaintext" ? "" : doc.languageId, code, pinned });

  try {

    const client = auth.clientFor(repo.base);

    const issue = await client.createIssue(repo.owner, repo.name, title, body);

    issues.refresh();

    references.clear();

    if (todoLine !== undefined) {

      const line = doc.lineAt(todoLine);

      const annotated = annotateTodo(line.text, issue.number);

      if (annotated !== line.text) {

        const pick = await vscode.window.showInformationMessage(`OxygenHub: opened #${issue.number}. Record it in the TODO?`, "Add (#" + issue.number + ")");

        if (pick) {

          await editor.edit((e) => e.replace(line.range, annotated));

        }

      }

    }

    await showIssue(auth, repo, issue);

  } catch (e) {

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

  }

}

/** Mark a draft ready for review, or turn an open proposal back into a draft. */

async function setDraft(repo: HubRepo, number: number, draft: boolean): Promise<void> {

  try {

    await auth.clientFor(repo.base).setProposalDraft(repo.owner, repo.name, number, draft);

    proposals.refresh();

    vscode.window.setStatusBarMessage(draft ? `$(circle-outline) #${number} is a draft again` : `$(git-pull-request) #${number} is ready for review`, 4000);

  } catch (e) {

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

  }

}

/** What you can land now, across every repository you write to (#311). */

async function landable(): Promise<void> {

  const repos = await proposals.repos();

  type Item = vscode.QuickPickItem & { url: string; repo?: HubRepo; number: number };

  const items: Item[] = [];

  for (const base of auth.all().map((x) => x.base)) {

    const list = await auth.clientFor(base).userProposals(true).catch(() => undefined);

    for (const p of list?.landable ?? []) {

      const [owner, name] = p.repository.split("/");

      const repo = repos.find((r) => r.base === base && r.owner === owner && r.name === name);

      items.push({ label: `$(pass) #${p.number} ${p.title}`, description: `${p.repository} · ${p.author}`, detail: repo ? undefined : "not in this workspace: opens on the hub", url: p.url, repo, number: p.number });

    }

  }

  if (!items.length) {

    void vscode.window.showInformationMessage("OxygenHub: nothing is ready for you to land.");

    return;

  }

  const pick = await vscode.window.showQuickPick(items, { placeHolder: "Ready to land: approved, checks passed, no conflicts" });

  if (!pick) {

    return;

  }

  if (!pick.repo) {

    void vscode.env.openExternal(vscode.Uri.parse(pick.url));

    return;

  }

  const act = await vscode.window.showQuickPick(["Land", "Open"], { placeHolder: `#${pick.number}` });

  if (act === "Land") {

    await runInTerminal(pick.repo, `oxy proposal land ${pick.url}`);

  } else if (act === "Open") {

    await vscode.commands.executeCommand("oxygenhub.openProposal", { kind: "proposal", repo: pick.repo, p: await auth.clientFor(pick.repo.base).proposal(pick.repo.owner, pick.repo.name, pick.number) });

  }

}

export function deactivate(): void {}