// Review threads on the checked-out proposal (spec §6): a comment

// controller whose threads are the hub's anchored comments, placed by

// asking oxy for each line's atom.

import * as vscode from "vscode";

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

import { HubAuth } from "./auth";

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

import { diffUri, refOf } from "./diff";

interface BlameLine {

  line: number;

  hash: string;

  index: number;

}

/** The hub's comments as threads on files under the repository root. */

export class ReviewController implements vscode.Disposable {

  private readonly controller = vscode.comments.createCommentController("oxygenhub", "OxygenHub review");

  private threads: vscode.CommentThread[] = [];

  private active: { repo: HubRepo; number: number } | undefined;

  /** Threads in diff editors, per proposal (`base/owner/name#n`). */

  private readonly diffThreads = new Map<string, vscode.CommentThread[]>();

  constructor(private readonly auth: HubAuth) {

    this.controller.commentingRangeProvider = {

      provideCommentingRanges: (document) => {

        const whole = [new vscode.Range(0, 0, Math.max(0, document.lineCount - 1), 0)];

        // In a proposal's diff, only the projected side takes comments.

        const r = refOf(document.uri);

        if (r) {

          return r.side === "head" ? whole : [];

        }

        return this.active && document.uri.fsPath.startsWith(this.active.repo.handle.root) ? whole : [];

      },

    };

  }

  /**

   * Show a proposal's threads in its diff documents: every anchored

   * comment on the projected side, at the line the hub places it.

   */

  async loadDiff(repo: RepoRef, number: number): Promise<void> {

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

    this.diffThreads.get(key)?.forEach((t) => t.dispose());

    const comments = await this.auth.clientFor(repo.base).proposalComments(repo.owner, repo.name, number);

    const byLine = new Map<string, api.Comment[]>();

    for (const c of comments) {

      if (c.path && c.line) {

        const k = `${c.path}\n${c.line}`;

        byLine.set(k, [...(byLine.get(k) ?? []), c]);

      }

    }

    const threads: vscode.CommentThread[] = [];

    for (const [k, cs] of byLine) {

      const [path, line] = k.split("\n");

      const thread = this.controller.createCommentThread(diffUri(repo, number, "head", path), new vscode.Range(Number(line) - 1, 0, Number(line) - 1, 0), cs.map(toComment));

      thread.label = cs.every((c) => c.resolved) ? "resolved" : "review";

      thread.state = cs.every((c) => c.resolved) ? vscode.CommentThreadState.Resolved : vscode.CommentThreadState.Unresolved;

      thread.collapsibleState = vscode.CommentThreadCollapsibleState.Expanded;

      threads.push(thread);

    }

    this.diffThreads.set(key, threads);

  }

  /** Show the threads of a proposal; call after checking it out. */

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

    this.clear();

    this.active = { repo, number };

    const comments = await this.auth.clientFor(repo.base).proposalComments(repo.owner, repo.name, number);

    const byPath = new Map<string, api.Comment[]>();

    for (const c of comments) {

      if (c.path && c.anchor) {

        byPath.set(c.path, [...(byPath.get(c.path) ?? []), c]);

      }

    }

    for (const [path, list] of byPath) {

      let blame: BlameLine[] = [];

      try {

        blame = await repo.handle.json<BlameLine[]>(["blame", path, "--json"]);

      } catch {

        continue;

      }

      const uri = vscode.Uri.file(`${repo.handle.root}/${path}`);

      // One thread per atom.

      const byAtom = new Map<string, api.Comment[]>();

      for (const c of list) {

        const key = `${c.anchor!.change}:${c.anchor!.index}`;

        byAtom.set(key, [...(byAtom.get(key) ?? []), c]);

      }

      for (const [key, cs] of byAtom) {

        const [hash, index] = key.split(":");

        const line = blame.find((b) => b.hash === hash && String(b.index) === index)?.line;

        if (!line) {

          continue;

        }

        const thread = this.controller.createCommentThread(uri, new vscode.Range(line - 1, 0, line - 1, 0), cs.map(toComment));

        thread.label = cs[0].resolved ? "resolved" : "review";

        thread.state = cs[0].resolved ? vscode.CommentThreadState.Resolved : vscode.CommentThreadState.Unresolved;

        thread.collapsibleState = vscode.CommentThreadCollapsibleState.Expanded;

        this.threads.push(thread);

      }

    }

  }

  /** Post a reply to a thread, anchored to the line it sits on. */

  async reply(reply: vscode.CommentReply): Promise<void> {

    const r = refOf(reply.thread.uri);

    if (r) {

      const line = (reply.thread.range?.start.line ?? 0) + 1;

      const repo: RepoRef = { base: r.base, owner: r.owner, name: r.name };

      try {

        await postLineComment(this.auth, repo, r.number, r.path, line, reply.text);

      } catch (e) {

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

        return;

      }

      // A new thread from the gutter is replaced by the hub's copy.

      if (!reply.thread.comments.length) {

        reply.thread.dispose();

      }

      await this.loadDiff(repo, r.number);

      return;

    }

    const a = this.active;

    if (!a) {

      return;

    }

    const rel = reply.thread.uri.fsPath.slice(a.repo.handle.root.length + 1);

    const line = reply.thread.range?.start.line ?? 0;

    // The hub resolves the line to its atom, so the thread follows the line through rebases.

    await postLineComment(this.auth, a.repo, a.number, rel, line + 1, reply.text);

    await this.load(a.repo, a.number);

  }

  clear(): void {

    this.threads.forEach((t) => t.dispose());

    this.threads = [];

    this.active = undefined;

  }

  dispose(): void {

    this.clear();

    this.diffThreads.forEach((ts) => ts.forEach((t) => t.dispose()));

    this.diffThreads.clear();

    this.controller.dispose();

  }

}

function toComment(c: api.Comment): vscode.Comment {

  return { body: new vscode.MarkdownString(c.body), mode: vscode.CommentMode.Preview, author: { name: c.author }, label: c.resolved ? "resolved" : undefined, timestamp: new Date(c.created_ms) };

}

/** A comment anchored to the atom at `path:line` of the projected state. */

async function postLineComment(auth: HubAuth, repo: RepoRef, number: number, path: string, line: number, body: string): Promise<void> {

  await auth.clientFor(repo.base).commentProposal(repo.owner, repo.name, number, body, path, line);

}