// Proposals in VS Code's own diff editors (spec §6.1): each side of a
// changed file is a read-only document served from the hub, the target's
// state on the left and the projected state on the right, so a proposal
// can be read and reviewed without checking it out.

import * as vscode from "vscode";
import type * as api from "./hubapi";
import { HubAuth } from "./auth";
import { DiffRef, decodeDiffQuery, encodeDiffQuery } from "./hub";
import type { RepoRef } from "./proposals";

export const SCHEME = "oxygenhub-proposal";

/** The document URI of one side of a file in a proposal. */
export function diffUri(repo: RepoRef, number: number, side: "base" | "head", path: string): vscode.Uri {
  return vscode.Uri.from({ scheme: SCHEME, path: `/${path}`, query: encodeDiffQuery({ base: repo.base, owner: repo.owner, name: repo.name, number, side, path }) });
}

/** The proposal, side and path a document of this scheme shows. */
export function refOf(uri: vscode.Uri): DiffRef | undefined {
  return uri.scheme === SCHEME ? decodeDiffQuery(uri.query, uri.path) : undefined;
}

/** Serves both sides from the hub; a side where the file is absent is empty. */
export class ProposalContentProvider implements vscode.TextDocumentContentProvider, vscode.Disposable {
  private readonly emitter = new vscode.EventEmitter<vscode.Uri>();
  readonly onDidChange = this.emitter.event;
  private readonly open = new Set<string>();

  constructor(private readonly auth: HubAuth) {}

  async provideTextDocumentContent(uri: vscode.Uri): Promise<string> {
    const r = refOf(uri);
    if (!r) {
      return "";
    }
    this.open.add(uri.toString());
    try {
      return (await this.auth.clientFor(r.base).proposalContent(r.owner, r.name, r.number, r.side, r.path)) ?? "";
    } catch (e) {
      void vscode.window.showWarningMessage(`OxygenHub: could not load ${r.path}: ${(e as Error).message}`);
      return "";
    }
  }

  /** Reload every open side of a proposal, after it gains changes. */
  refresh(base: string, owner: string, name: string, number: number): void {
    for (const s of this.open) {
      const r = refOf(vscode.Uri.parse(s));
      if (r && r.base === base && r.owner === owner && r.name === name && r.number === number) {
        this.emitter.fire(vscode.Uri.parse(s));
      }
    }
  }

  dispose(): void {
    this.emitter.dispose();
  }
}

function sides(repo: RepoRef, number: number, f: api.ProposalFile): { left: vscode.Uri; right: vscode.Uri } {
  return { left: diffUri(repo, number, "base", f.from ?? f.path), right: diffUri(repo, number, "head", f.path) };
}

/** One file in a diff editor. */
export async function openFileDiff(repo: RepoRef, number: number, f: api.ProposalFile): Promise<void> {
  const { left, right } = sides(repo, number, f);
  const title = `#${number} ${f.from ? `${f.from} → ${f.path}` : f.path} (${f.kind})`;
  await vscode.commands.executeCommand("vscode.diff", left, right, title, { preview: true });
}

/** Every file of a proposal in one multi-file diff editor. */
export async function openAllChanges(repo: RepoRef, p: api.Proposal, files: api.ProposalFile[]): Promise<void> {
  if (!files.length) {
    void vscode.window.showInformationMessage(`OxygenHub: #${p.number} changes no files.`);
    return;
  }
  const resources = files.map((f) => {
    const { left, right } = sides(repo, p.number, f);
    return [right, left, right];
  });
  await vscode.commands.executeCommand("vscode.changes", `#${p.number} ${p.title}`, resources);
}