// The Releases view (spec §8.2): each repository's releases with their

// assets, and drafting a release from a tag with notes from history.

import * as vscode from "vscode";

import type * as api from "./hubapi";

import { HubAuth } from "./auth";

import { looksPrerelease, releaseNotes, trustMarkdown } from "./hub";

import type { HubRepo } from "./proposals";

type Node =

  | { kind: "repo"; repo: HubRepo }

  | { kind: "release"; repo: HubRepo; r: api.Release }

  | { kind: "asset"; repo: HubRepo; r: api.Release; name: string; url: string; size?: number; downloads?: number };

export type ReleaseNode = Extract<Node, { kind: "release" }>;

export type AssetNode = Extract<Node, { kind: "asset" }>;

export class ReleasesProvider implements vscode.TreeDataProvider<Node> {

  private readonly emitter = new vscode.EventEmitter<void>();

  readonly onDidChangeTreeData = this.emitter.event;

  constructor(

    private readonly repos: () => Promise<HubRepo[]>,

    private readonly auth: HubAuth,

  ) {}

  refresh(): void {

    this.emitter.fire();

  }

  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 = "releaseRepo";

        return item;

      }

      case "release": {

        const r = node.r;

        const item = new vscode.TreeItem(r.title || r.tag, vscode.TreeItemCollapsibleState.Collapsed);

        item.description = [r.tag, r.latest ? "latest" : "", r.prerelease ? "pre-release" : "", new Date(r.created_ms).toLocaleDateString()].filter(Boolean).join(" · ");

        item.iconPath = new vscode.ThemeIcon(r.prerelease ? "beaker" : "tag");

        item.tooltip = new vscode.MarkdownString(`**${r.title || r.tag}** · ${r.tag} by ${r.author}\n\n${r.notes.slice(0, 600)}`);

        item.contextValue = "release";

        item.command = { title: "Open", command: "vscode.open", arguments: [vscode.Uri.parse(r.url)] };

        return item;

      }

      case "asset": {

        const item = new vscode.TreeItem(node.name, vscode.TreeItemCollapsibleState.None);

        item.description = node.size !== undefined ? `${formatSize(node.size)} · ${node.downloads ?? 0} downloads` : "source archive";

        item.iconPath = new vscode.ThemeIcon(node.size !== undefined ? "package" : "file-zip");

        item.contextValue = "releaseAsset";

        item.command = { title: "Download", command: "vscode.open", arguments: [vscode.Uri.parse(node.url)] };

        return item;

      }

    }

  }

  async getChildren(node?: Node): Promise<Node[]> {

    if (!node) {

      return (await this.repos()).map((repo) => ({ kind: "repo", repo }));

    }

    if (node.kind === "repo") {

      try {

        const list = await this.auth.clientFor(node.repo.base).releases(node.repo.owner, node.repo.name);

        return list.map((r) => ({ kind: "release", repo: node.repo, r }));

      } catch (e) {

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

        return [];

      }

    }

    if (node.kind === "release") {

      const assets: Node[] = node.r.assets.map((a) => ({ kind: "asset", repo: node.repo, r: node.r, name: a.name, url: a.url, size: a.size, downloads: a.downloads }));

      const archives: Node[] = node.r.archives.map((url) => ({ kind: "asset", repo: node.repo, r: node.r, name: url.split("/").pop() ?? url, url }));

      return [...assets, ...archives];

    }

    return [];

  }

}

function formatSize(n: number): string {

  return n >= 1 << 20 ? `${(n / (1 << 20)).toFixed(1)} MiB` : n >= 1024 ? `${(n / 1024).toFixed(1)} KiB` : `${n} B`;

}

/** Draft a release: a tag without one, a title, notes from the changes since the last release. */

export async function draftRelease(auth: HubAuth, repo: HubRepo): Promise<api.Release | undefined> {

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

  const [tags, releases] = await Promise.all([client.tags(repo.owner, repo.name), client.releases(repo.owner, repo.name)]);

  const released = new Set(releases.map((r) => r.tag));

  const open = tags.filter((t) => !released.has(t.name));

  if (!open.length) {

    void vscode.window.showInformationMessage(`OxygenHub: every tag of ${repo.owner}/${repo.name} has a release. Tag a state with \`oxy tag create\` and push it first.`);

    return undefined;

  }

  const pick = await vscode.window.showQuickPick(

    open.map((t) => ({ label: t.name, description: t.message.split("\n")[0], detail: t.signer ? "signed" : undefined, t })),

    { placeHolder: "Tag to release" },

  );

  if (!pick) {

    return undefined;

  }

  const title = await vscode.window.showInputBox({ prompt: "Release title", value: pick.t.message.split("\n")[0] || pick.label });

  if (title === undefined) {

    return undefined;

  }

  const previous = releases.filter((r) => !r.prerelease).sort((a, b) => b.created_ms - a.created_ms)[0];

  const current = await client.history(repo.owner, repo.name, pick.label, 500);

  const before = previous ? await client.history(repo.owner, repo.name, previous.tag, 500) : { changes: [] as api.ChangeSummary[] };

  const notes = releaseNotes(current.changes, before.changes, previous?.tag);

  const pre = await vscode.window.showQuickPick(

    [

      { label: "Release", pre: false },

      { label: "Pre-release", pre: true },

    ].sort((a) => (a.pre === looksPrerelease(pick.label) ? -1 : 1)),

    { placeHolder: "Kind" },

  );

  if (!pre) {

    return undefined;

  }

  return client.createRelease(repo.owner, repo.name, { tag: pick.label, title: title || pick.label, notes, prerelease: pre.pre });

}

/** A release's trust report (#79) as a Markdown preview: the tag's signature, who signed the changes, which build made each asset, and the audit. */

export async function showTrust(auth: HubAuth, node: ReleaseNode): Promise<void> {

  const t = await auth.clientFor(node.repo.base).releaseTrust(node.repo.owner, node.repo.name, node.r.tag);

  const doc = await vscode.workspace.openTextDocument({ content: trustMarkdown(t), language: "markdown" });

  await vscode.commands.executeCommand("markdown.showPreview", doc.uri);

}

/** Save a release's asset to a file, with the hub session's token when it needs one. */

export async function saveAsset(auth: HubAuth, node: AssetNode): Promise<void> {

  const folder = vscode.workspace.workspaceFolders?.[0]?.uri;

  const target = await vscode.window.showSaveDialog({ defaultUri: folder ? vscode.Uri.joinPath(folder, node.name) : undefined, saveLabel: "Save Asset" });

  if (!target) {

    return;

  }

  const bytes = await vscode.window.withProgress({ location: vscode.ProgressLocation.Notification, title: `OxygenHub: downloading ${node.name}…` }, () =>

    auth.clientFor(node.repo.base).download(node.url),

  );

  await vscode.workspace.fs.writeFile(target, bytes);

  vscode.window.setStatusBarMessage(`$(check) Saved ${node.name}`, 4000);

}