// `#N` and `@user` completion, and hover on `#N` (spec §6.2), in the
// Oxygen commit box and in review comments. The numbers are the
// repository's issues and proposals (one number space, as on the hub);
// the users are the people who opened or are assigned to them.

import * as vscode from "vscode";
import type * as api from "./hubapi";
import { HubAuth } from "./auth";
import type { HubRepo } from "./proposals";
import { numberAt, rootFromScmQuery, typingAt } from "./refs";

interface Ref {
  number: number;
  kind: "issue" | "proposal";
  title: string;
  state: string;
  author: string;
}

interface Index {
  at: number;
  refs: Map<number, Ref>;
  users: Set<string>;
}

/** How long an index is reused before the hub is asked again. */
const FRESH_MS = 60_000;

/** Where references are typed: the SCM commit box and comment editors. */
export const SELECTOR: vscode.DocumentSelector = [{ scheme: "vscode-scm" }, { scheme: "comment" }];

export class ReferenceIndex {
  private readonly cache = new Map<string, Index>();

  constructor(
    private readonly auth: HubAuth,
    private readonly repos: () => Promise<HubRepo[]>,
  ) {}

  clear(): void {
    this.cache.clear();
  }

  /** The repository a document types into: the SCM box's root, else the only hub repository. */
  async repoFor(doc: vscode.TextDocument): Promise<HubRepo | undefined> {
    const repos = await this.repos();
    const root = doc.uri.scheme === "vscode-scm" ? rootFromScmQuery(doc.uri.query) : undefined;
    if (root) {
      return repos.find((r) => r.handle.root === root);
    }
    return repos.length === 1 ? repos[0] : undefined;
  }

  async indexOf(repo: HubRepo): Promise<Index> {
    const key = `${repo.base}/${repo.owner}/${repo.name}`;
    const hit = this.cache.get(key);
    if (hit && Date.now() - hit.at < FRESH_MS) {
      return hit;
    }
    const client = this.auth.clientFor(repo.base);
    const [issues, proposals] = await Promise.all([client.issues(repo.owner, repo.name, "all").catch(() => [] as api.Issue[]), client.proposals(repo.owner, repo.name).catch(() => [] as api.Proposal[])]);
    const refs = new Map<number, Ref>();
    const users = new Set<string>();
    for (const i of issues) {
      refs.set(i.number, { number: i.number, kind: "issue", title: i.title, state: i.state, author: i.author });
      users.add(i.author);
      i.assignees.forEach((a) => users.add(a));
    }
    for (const p of proposals) {
      refs.set(p.number, { number: p.number, kind: "proposal", title: p.title, state: p.state, author: p.author });
      users.add(p.author);
    }
    const me = this.auth.sessionFor(repo.base)?.username;
    if (me) {
      users.add(me);
    }
    users.delete("");
    const index = { at: Date.now(), refs, users };
    this.cache.set(key, index);
    return index;
  }
}

export class ReferenceCompletions implements vscode.CompletionItemProvider {
  constructor(private readonly index: ReferenceIndex) {}

  async provideCompletionItems(doc: vscode.TextDocument, pos: vscode.Position): Promise<vscode.CompletionItem[]> {
    const before = doc.lineAt(pos.line).text.slice(0, pos.character);
    const typing = typingAt(before);
    const repo = typing && (await this.index.repoFor(doc));
    if (!typing || !repo) {
      return [];
    }
    const idx = await this.index.indexOf(repo);
    const range = new vscode.Range(pos.line, typing.start, pos.line, pos.character);
    if (typing.kind === "number") {
      // Open items first, then newest.
      const refs = [...idx.refs.values()].sort((a, b) => Number(a.state !== "open") - Number(b.state !== "open") || b.number - a.number);
      return refs.map((r, i) => {
        const item = new vscode.CompletionItem({ label: `#${r.number}`, description: r.title }, r.kind === "issue" ? vscode.CompletionItemKind.Issue : vscode.CompletionItemKind.Reference);
        item.detail = `${r.kind} · ${r.state} · ${r.author}`;
        item.filterText = `#${r.number} ${r.title}`;
        item.sortText = String(i).padStart(6, "0");
        item.insertText = `#${r.number}`;
        item.range = range;
        return item;
      });
    }
    return [...idx.users].sort().map((u) => {
      const item = new vscode.CompletionItem(`@${u}`, vscode.CompletionItemKind.User);
      item.insertText = `@${u}`;
      item.range = range;
      return item;
    });
  }
}

export class ReferenceHovers implements vscode.HoverProvider {
  constructor(private readonly index: ReferenceIndex) {}

  async provideHover(doc: vscode.TextDocument, pos: vscode.Position): Promise<vscode.Hover | undefined> {
    const at = numberAt(doc.lineAt(pos.line).text, pos.character);
    const repo = at && (await this.index.repoFor(doc));
    if (!at || !repo) {
      return undefined;
    }
    const r = (await this.index.indexOf(repo)).refs.get(at.number);
    if (!r) {
      return undefined;
    }
    const url = `${repo.base}/${repo.owner}/${repo.name}/${r.kind}/${r.number}`;
    const md = new vscode.MarkdownString(`**${r.kind === "issue" ? "Issue" : "Proposal"} #${r.number}** · ${r.state}\n\n${r.title}\n\n_${r.author}_ · [open on the hub](${url})`);
    return new vscode.Hover(md, new vscode.Range(pos.line, at.start, pos.line, at.end));
  }
}