// The Proposals view (spec §5): per repository with a hub remote, three
// buckets, a detail webview, and the actions.

import * as vscode from "vscode";
import type * as api from "./hubapi";
import { HubAuth } from "./auth";
import { hubUrl, needsMe, parseRepoUrl } from "./hub";
import type { OxygenAPI, RepositoryHandle } from "./oxygenapi";

/** A repository in the workspace with a hub remote. */
export interface HubRepo {
  handle: RepositoryHandle;
  base: string;
  owner: string;
  name: string;
  remote: string;
}

/** Just enough to name a repository on a hub. */
export type RepoRef = Pick<HubRepo, "base" | "owner" | "name">;

/** Find the hub remotes of every repository the Oxygen extension knows. */
export async function hubRepos(oxygen: OxygenAPI, auth: HubAuth): Promise<HubRepo[]> {
  const out: HubRepo[] = [];
  const bases = auth.bases();
  for (const handle of oxygen.repositories) {
    let remotes: { name: string; url: string; ca?: string }[] = [];
    try {
      remotes = await handle.remotes();
    } catch {
      continue;
    }
    for (const r of remotes) {
      const p = parseRepoUrl(r.url);
      if (p && r.ca) {
        auth.setCa(p.base, r.ca);
      }
      if (p && bases.includes(p.base)) {
        out.push({ handle, base: p.base, owner: p.owner, name: p.name, remote: r.name });
        break;
      }
    }
  }
  return out;
}

type Node =
  | { kind: "repo"; repo: HubRepo }
  | { kind: "bucket"; repo: HubRepo; label: string; items: api.Proposal[] }
  | { kind: "proposal"; repo: HubRepo; p: api.Proposal }
  | { kind: "file"; repo: HubRepo; p: api.Proposal; f: api.ProposalFile };

const FILE_ICONS: Record<string, string> = { added: "diff-added", removed: "diff-removed", renamed: "diff-renamed", modified: "diff-modified" };

export class ProposalsProvider implements vscode.TreeDataProvider<Node> {
  private readonly emitter = new vscode.EventEmitter<void>();
  readonly onDidChangeTreeData = this.emitter.event;
  private cache = new Map<string, api.Proposal[]>();
  private files = new Map<string, api.ProposalFile[]>();

  constructor(
    private readonly oxygen: () => OxygenAPI | undefined,
    private readonly auth: HubAuth,
  ) {}

  refresh(): void {
    this.cache.clear();
    this.files.clear();
    this.emitter.fire();
  }

  async repos(): Promise<HubRepo[]> {
    const o = this.oxygen();
    return o ? hubRepos(o, this.auth) : [];
  }

  async proposalsOf(repo: HubRepo): Promise<api.Proposal[]> {
    const key = `${repo.base}/${repo.owner}/${repo.name}`;
    const hit = this.cache.get(key);
    if (hit) {
      return hit;
    }
    const list = await this.auth.clientFor(repo.base).proposals(repo.owner, repo.name);
    this.cache.set(key, list);
    return list;
  }

  /** The files a proposal changes, cached until the next refresh. */
  async filesOf(repo: HubRepo, p: api.Proposal): Promise<api.ProposalFile[]> {
    const key = `${repo.base}/${repo.owner}/${repo.name}#${p.number}`;
    const hit = this.files.get(key);
    if (hit) {
      return hit;
    }
    const list = await this.auth.clientFor(repo.base).proposalFiles(repo.owner, repo.name, p.number);
    this.files.set(key, list);
    return list;
  }

  getTreeItem(node: Node): vscode.TreeItem {
    switch (node.kind) {
      case "repo": {
        const item = new vscode.TreeItem(`${node.repo.owner}/${node.repo.name}`, vscode.TreeItemCollapsibleState.Expanded);
        item.iconPath = new vscode.ThemeIcon("repo");
        item.contextValue = "repo";
        return item;
      }
      case "bucket": {
        const item = new vscode.TreeItem(`${node.label} (${node.items.length})`, node.items.length ? vscode.TreeItemCollapsibleState.Expanded : vscode.TreeItemCollapsibleState.Collapsed);
        item.contextValue = "bucket";
        return item;
      }
      case "proposal": {
        const p = node.p;
        const item = new vscode.TreeItem(`#${p.number} ${p.title}`, vscode.TreeItemCollapsibleState.Collapsed);
        const sealed = p.approvals.filter((a) => a.sealed).length;
        const chips = [p.state === "draft" ? "draft" : "", p.conflicted ? "conflicts" : "", p.landable ? "landable" : "", sealed ? `${sealed} sealed` : ""].filter(Boolean).join(" · ");
        item.description = `${p.author} → ${p.target}${chips ? " · " + chips : ""}`;
        item.tooltip = new vscode.MarkdownString(`**${p.title}** by ${p.author}\n\n${p.changes.length} change(s) into ${p.target}\n\n${p.blockers.length ? "Blocked: " + p.blockers.join("; ") : "Ready to land"}`);
        item.iconPath = new vscode.ThemeIcon(p.conflicted ? "warning" : p.landable ? "pass" : p.state === "draft" ? "circle-outline" : "git-pull-request");
        // `proposal` or `proposalDraft`: a draft is marked ready, an open one turned back into a draft.
        item.contextValue = p.state === "draft" ? "proposalDraft" : "proposal";
        item.command = { title: "Open", command: "oxygenhub.openProposal", arguments: [node] };
        return item;
      }
      case "file": {
        const f = node.f;
        const slash = f.path.lastIndexOf("/");
        const item = new vscode.TreeItem(f.path.slice(slash + 1), vscode.TreeItemCollapsibleState.None);
        const dir = slash > 0 ? f.path.slice(0, slash) : "";
        item.description = [dir, f.from ? `from ${f.from}` : "", f.added || f.removed ? `+${f.added} −${f.removed}` : f.kind].filter(Boolean).join(" · ");
        item.tooltip = `${f.path} (${f.kind})`;
        item.iconPath = new vscode.ThemeIcon(FILE_ICONS[f.kind] ?? "diff");
        item.contextValue = "proposalFile";
        item.command = { title: "Open Diff", command: "oxygenhub.openProposalFile", arguments: [node] };
        return item;
      }
    }
  }

  async getChildren(node?: Node): Promise<Node[]> {
    if (!node) {
      const repos = await this.repos();
      return repos.map((repo) => ({ kind: "repo", repo }));
    }
    if (node.kind === "repo") {
      let list: api.Proposal[] = [];
      try {
        list = await this.proposalsOf(node.repo);
      } catch (e) {
        void vscode.window.showWarningMessage(`OxygenHub: ${(e as Error).message}`);
        return [];
      }
      const me = this.auth.sessionFor(node.repo.base)?.username;
      const mine = list.filter((p) => p.author === me);
      const needing = list.filter((p) => needsMe(p, me));
      const rest = list.filter((p) => !mine.includes(p) && !needing.includes(p));
      return [
        { kind: "bucket", repo: node.repo, label: "Needing me", items: needing },
        { kind: "bucket", repo: node.repo, label: "Mine", items: mine },
        { kind: "bucket", repo: node.repo, label: "Open", items: rest },
      ];
    }
    if (node.kind === "bucket") {
      return node.items.map((p) => ({ kind: "proposal", repo: node.repo, p }));
    }
    if (node.kind === "proposal") {
      try {
        const files = await this.filesOf(node.repo, node.p);
        return files.map((f) => ({ kind: "file", repo: node.repo, p: node.p, f }));
      } catch (e) {
        void vscode.window.showWarningMessage(`OxygenHub: ${(e as Error).message}`);
      }
    }
    return [];
  }
}

export type ProposalNode = Extract<Node, { kind: "proposal" }>;
export type ProposalFileNode = Extract<Node, { kind: "file" }>;

/** The detail webview. */
export function showDetail(repo: HubRepo, p: api.Proposal, checks: api.Check[]): void {
  const panel = vscode.window.createWebviewPanel("oxygenhub.proposal", `#${p.number} ${p.title}`, vscode.ViewColumn.Beside, { enableCommandUris: true });
  const esc = (s: string) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
  const changes = p.changes.map((c) => `<li><code>${c.hash.slice(0, 12)}</code> ${esc(c.message.split("\n")[0])} <span class="mute">${esc(c.author.name)} · ${c.signature.status}</span></li>`).join("");
  const approvals = p.approvals.map((a) => `<li>${a.sealed ? "◈" : "○"} ${esc(a.account)}${a.sealed ? "" : " (seal pending)"}</li>`).join("") || "<li class=mute>none</li>";
  const blockers = p.blockers.map((b) => `<li>✘ ${esc(b)}</li>`).join("") || "<li>✔ ready to land</li>";
  const checkRows = checks.map((c) => `<li>${c.status === "passed" ? "✔" : c.status === "failed" ? "✘" : "…"} ${esc(c.name)} <span class=mute>${c.status}${c.summary ? " · " + esc(c.summary) : ""}</span></li>`).join("") || "<li class=mute>none</li>";
  const url = hubUrl(repo.base, repo.owner, repo.name, { kind: "proposal", number: p.number });
  const arg = encodeURIComponent(JSON.stringify([repo.base, repo.owner, repo.name, p.number]));
  panel.webview.html = `<!doctype html><html><body style="font-family: var(--vscode-font-family); padding: 12px">
  <h2>#${p.number} ${esc(p.title)} <small>${p.state}</small></h2>
  <p>${esc(p.author)} wants <b>${esc(JSON.stringify(p.source))}</b> into <b>${esc(p.target)}</b> · ${p.changes.length} change(s)${p.conflicted ? " · <b>conflicts</b>" : ""}</p>
  <p><a href="${url}">Open on hub</a> · <a href="command:oxygenhub.openProposalChanges?${arg}">View changes</a> · <a href="command:oxygenhub.checkoutProposal?${arg}">Check out</a> · <a href="command:oxygenhub.review?${arg}">Review</a> · <a href="command:oxygenhub.sealApproval?${arg}">Seal approval</a> · <a href="command:oxygenhub.land?${arg}">Land</a></p>
  <div>${p.body ? `<pre style="white-space: pre-wrap">${esc(p.body)}</pre>` : ""}</div>
  <h3>Landing</h3><ul>${blockers}</ul>
  <h3>Approvals</h3><ul>${approvals}</ul>
  <h3>Checks</h3><ul>${checkRows}</ul>
  <h3>Changes</h3><ul>${changes}</ul>
  <style>.mute{opacity:.7} small{font-weight:normal;opacity:.7}</style>
  </body></html>`;
}