// Inline blame (spec §5.8): each line's introducing change, author and age
// at the end of the line, computed on the base version and aligned to the
// editor's current text so unsaved edits show as unattributed.

import * as vscode from "vscode";
import { basename } from "node:path";
import { alignLines } from "./diffutil";
import { BlameLine } from "./oxy";
import { Repository } from "./repository";
import { timeAgo } from "./operations";

export class BlameController implements vscode.Disposable {
  private enabled: boolean;
  private readonly decoration: vscode.TextEditorDecorationType;
  private readonly disposables: vscode.Disposable[] = [];
  private cache = new Map<string, { base: string; lines: BlameLine[] }>();
  private timer: NodeJS.Timeout | undefined;

  constructor(private readonly repositories: () => Repository[]) {
    this.enabled = vscode.workspace.getConfiguration("oxygen").get<boolean>("inlineBlame", false);
    this.decoration = vscode.window.createTextEditorDecorationType({
      after: { margin: "0 0 0 3em", color: new vscode.ThemeColor("editorCodeLens.foreground"), fontStyle: "italic" },
      rangeBehavior: vscode.DecorationRangeBehavior.ClosedOpen,
    });
    this.disposables.push(
      this.decoration,
      vscode.window.onDidChangeActiveTextEditor(() => this.schedule()),
      vscode.workspace.onDidChangeTextDocument((e) => e.document === vscode.window.activeTextEditor?.document && this.schedule()),
      vscode.workspace.onDidSaveTextDocument(() => this.schedule()),
      vscode.workspace.onDidChangeConfiguration((e) => {
        if (e.affectsConfiguration("oxygen.inlineBlame")) {
          this.enabled = vscode.workspace.getConfiguration("oxygen").get<boolean>("inlineBlame", false);
          this.schedule();
        }
      }),
    );
    this.schedule();
  }

  toggle(): void {
    this.enabled = !this.enabled;
    void vscode.workspace.getConfiguration("oxygen").update("inlineBlame", this.enabled, vscode.ConfigurationTarget.Global);
    this.schedule();
  }

  /** Forget cached blame for a repository (after any operation). */
  invalidate(root: string): void {
    for (const key of [...this.cache.keys()]) {
      if (key.startsWith(root + "\0")) {
        this.cache.delete(key);
      }
    }
    this.schedule();
  }

  private schedule(): void {
    if (this.timer) {
      clearTimeout(this.timer);
    }
    this.timer = setTimeout(() => void this.apply(), 200);
  }

  private async apply(): Promise<void> {
    const editor = vscode.window.activeTextEditor;
    if (!editor) {
      return;
    }
    if (!this.enabled) {
      editor.setDecorations(this.decoration, []);
      return;
    }
    const repo = this.repositories().find((r) => r.relativePath(editor.document.uri) !== undefined);
    const rel = repo?.relativePath(editor.document.uri);
    if (!repo || !rel) {
      editor.setDecorations(this.decoration, []);
      return;
    }
    const key = repo.root + "\0" + rel;
    let entry = this.cache.get(key);
    if (!entry) {
      try {
        const [base, lines] = await Promise.all([repo.oxy.cat(repo.root, rel), repo.oxy.blame(repo.root, rel)]);
        entry = { base: base.toString("utf8"), lines };
        this.cache.set(key, entry);
      } catch {
        editor.setDecorations(this.decoration, []);
        return;
      }
    }
    if (vscode.window.activeTextEditor !== editor) {
      return;
    }
    const baseLines = splitLines(entry.base);
    const nowLines = splitLines(editor.document.getText());
    const map = alignLines(baseLines, nowLines);
    const byLine = new Map(entry.lines.map((l) => [l.line - 1, l]));
    const decorations: vscode.DecorationOptions[] = [];
    for (let i = 0; i < editor.document.lineCount; i++) {
      const baseIndex = map[i];
      const blame = baseIndex >= 0 ? byLine.get(baseIndex) : undefined;
      const text = blame ? `${blame.change_id.slice(0, 8)} · ${blame.author} · ${timeAgo(blame.when_ms)}` : i < nowLines.length && nowLines[i].length > 0 ? "uncommitted" : "";
      if (!text) {
        continue;
      }
      const line = editor.document.lineAt(i);
      decorations.push({
        range: new vscode.Range(line.range.end, line.range.end),
        renderOptions: { after: { contentText: text } },
        hoverMessage: blame ? new vscode.MarkdownString(`**${blame.author}** · ${new Date(blame.when_ms).toLocaleString()}\n\nChange \`${blame.change_id}\`\n\n[Show change](command:oxygen.showChange?${encodeURIComponent(JSON.stringify([repo.root, blame.hash]))})`, true) : undefined,
      });
    }
    for (const d of decorations) {
      if (d.hoverMessage instanceof vscode.MarkdownString) {
        d.hoverMessage.isTrusted = true;
      }
    }
    editor.setDecorations(this.decoration, decorations);
  }

  dispose(): void {
    if (this.timer) {
      clearTimeout(this.timer);
    }
    for (const d of this.disposables) {
      d.dispose();
    }
  }
}

function splitLines(text: string): string[] {
  const lines = text.split(/\r?\n/);
  if (lines.length > 0 && lines[lines.length - 1] === "") {
    lines.pop();
  }
  return lines;
}

export function blameTitle(path: string): string {
  return `Blame: ${basename(path)}`;
}