// One Oxygen repository as VS Code sees it: the source control provider,
// its resource groups, the status bar item, and the watchers that keep
// them fresh (spec §3, §5.1, §5.4).

import * as vscode from "vscode";
import { basename, join, relative } from "node:path";
import { isInStore } from "./paths";
import { BookmarkInfo, Oxy, PathStatus, StatusInfo, SubrepoInfo } from "./oxy";
import { baseUri } from "./contentProvider";

const STATUS_LETTER: Record<PathStatus, string> = {
  Added: "A",
  Modified: "M",
  Removed: "D",
  Renamed: "R",
  ModeChanged: "X",
  ConflictEdited: "‼",
  Resolved: "✔",
};

const STATUS_WORD: Record<PathStatus, string> = {
  Added: "added",
  Modified: "modified",
  Removed: "removed",
  Renamed: "renamed",
  ModeChanged: "mode changed",
  ConflictEdited: "conflict markers remain",
  Resolved: "conflict resolved",
};

const STATUS_COLOR: Record<PathStatus, string> = {
  Added: "oxygen.added",
  Modified: "oxygen.modified",
  Removed: "oxygen.removed",
  Renamed: "oxygen.renamed",
  ModeChanged: "oxygen.modified",
  ConflictEdited: "oxygen.conflict",
  Resolved: "oxygen.resolved",
};

export class OxyResourceState implements vscode.SourceControlResourceState {
  readonly resourceUri: vscode.Uri;
  readonly decorations: vscode.SourceControlResourceDecorations;
  readonly command: vscode.Command;

  constructor(
    readonly repository: Repository,
    readonly path: string,
    readonly status: PathStatus,
  ) {
    this.resourceUri = vscode.Uri.file(join(repository.root, path));
    this.decorations = {
      strikeThrough: status === "Removed",
      tooltip: STATUS_WORD[status],
      faded: false,
    };
    this.command = { command: "oxygen.openChanges", title: "Open Changes", arguments: [this] };
    this.contextValue = /\.oxy-conflict-\d+$/.test(path) ? "candidate" : status === "ConflictEdited" ? "markers" : status;
  }

  contextValue: string;

  get letter(): string {
    return STATUS_LETTER[this.status];
  }

  get color(): vscode.ThemeColor {
    return new vscode.ThemeColor(STATUS_COLOR[this.status]);
  }
}

export class SubrepoState implements vscode.SourceControlResourceState {
  readonly resourceUri: vscode.Uri;
  readonly decorations: vscode.SourceControlResourceDecorations;
  readonly command: vscode.Command;
  readonly contextValue = "subrepo";

  constructor(
    readonly repository: Repository,
    readonly info: SubrepoInfo,
  ) {
    this.resourceUri = vscode.Uri.file(join(repository.root, info.path));
    const pin = info.pin.kind === "oxy" ? `${info.pin.bookmark} ${info.pin.heads.map((h) => h.slice(0, 8)).join(" ")}` : `git ${info.pin.branch} ${info.pin.sha.slice(0, 10)}`;
    const state = !info.actual ? "missing (update --init)" : info.dirty ? "uncommitted changes inside" : info.at_pin ? "at pin" : "differs from pin";
    this.decorations = { tooltip: `${pin} · ${state}`, faded: !info.actual, strikeThrough: false };
    this.command = { command: "oxygen.openSubrepo", title: "Open", arguments: [this] };
  }
}

export class Repository implements vscode.Disposable, vscode.QuickDiffProvider {
  readonly sourceControl: vscode.SourceControl;
  readonly conflictsGroup: vscode.SourceControlResourceGroup;
  readonly changesGroup: vscode.SourceControlResourceGroup;
  readonly subreposGroup: vscode.SourceControlResourceGroup;
  private subreposLatest: SubrepoInfo[] = [];
  private readonly statusBar: vscode.StatusBarItem;
  private readonly syncBar: vscode.StatusBarItem;
  private bookmarksLatest: BookmarkInfo[] = [];
  private readonly disposables: vscode.Disposable[] = [];
  private readonly onDidChangeStatusEmitter = new vscode.EventEmitter<StatusInfo>();
  readonly onDidChangeStatus = this.onDidChangeStatusEmitter.event;
  private latest: StatusInfo | undefined;
  private refreshTimer: NodeJS.Timeout | undefined;
  private refreshing: Promise<void> | undefined;
  private refreshAgain = false;

  constructor(
    readonly oxy: Oxy,
    readonly root: string,
    readonly workspaceFolder: vscode.WorkspaceFolder | undefined,
  ) {
    const rootUri = vscode.Uri.file(root);
    this.sourceControl = vscode.scm.createSourceControl("oxygen", `Oxygen (${basename(root)})`, rootUri);
    this.sourceControl.quickDiffProvider = this;
    this.sourceControl.acceptInputCommand = { command: "oxygen.commit", title: "Commit", arguments: [this] };
    this.sourceControl.inputBox.placeholder = "Message (Ctrl+Enter to commit)";
    this.conflictsGroup = this.sourceControl.createResourceGroup("conflicts", "Conflicts");
    this.conflictsGroup.hideWhenEmpty = true;
    this.changesGroup = this.sourceControl.createResourceGroup("changes", "Changes");
    this.subreposGroup = this.sourceControl.createResourceGroup("subrepos", "Subrepos");
    this.subreposGroup.hideWhenEmpty = true;
    this.statusBar = vscode.window.createStatusBarItem("oxygen.status", vscode.StatusBarAlignment.Left, 100);
    this.statusBar.name = "Oxygen";
    this.statusBar.command = { command: "oxygen.switchBookmark", title: "Switch bookmark", arguments: [this] };
    this.syncBar = vscode.window.createStatusBarItem("oxygen.sync", vscode.StatusBarAlignment.Left, 99);
    this.syncBar.name = "Oxygen sync";
    this.syncBar.command = { command: "oxygen.sync", title: "Sync", arguments: [this] };
    this.disposables.push(this.sourceControl, this.conflictsGroup, this.changesGroup, this.subreposGroup, this.statusBar, this.syncBar, this.onDidChangeStatusEmitter);

    if (vscode.workspace.getConfiguration("oxygen").get<boolean>("autoRefresh", true)) {
      // Files in the workspace, except any repository store: this one's and
      // a subrepo's, which oxy itself writes while reporting status.
      const files = vscode.workspace.createFileSystemWatcher(new vscode.RelativePattern(rootUri, "**/*"));
      const onFile = (uri: vscode.Uri) => {
        if (!isInStore(relative(root, uri.fsPath))) {
          this.scheduleRefresh();
        }
      };
      files.onDidChange(onFile, this, this.disposables);
      files.onDidCreate(onFile, this, this.disposables);
      files.onDidDelete(onFile, this, this.disposables);
      this.disposables.push(files);
      // Any operation, including ones run from a terminal, moves the op head.
      const ops = vscode.workspace.createFileSystemWatcher(new vscode.RelativePattern(rootUri, ".oxy/ops/head"));
      ops.onDidChange(() => this.scheduleRefresh(), this, this.disposables);
      ops.onDidCreate(() => this.scheduleRefresh(), this, this.disposables);
      this.disposables.push(ops);
    }
    vscode.window.onDidChangeWindowState((s) => s.focused && this.scheduleRefresh(), this, this.disposables);
  }

  get status(): StatusInfo | undefined {
    return this.latest;
  }

  get bookmarks(): BookmarkInfo[] {
    return this.bookmarksLatest;
  }

  get subrepos(): SubrepoInfo[] {
    return this.subreposLatest;
  }

  get currentBookmark(): BookmarkInfo | undefined {
    return this.bookmarksLatest.find((b) => b.current);
  }

  /** The repository-relative path of a file under this root, or undefined. */
  relativePath(uri: vscode.Uri): string | undefined {
    if (uri.scheme !== "file") {
      return undefined;
    }
    const rel = relative(this.root, uri.fsPath);
    if (!rel || rel.startsWith("..") || rel.startsWith(".oxy")) {
      return undefined;
    }
    return rel.split("\\").join("/");
  }

  scheduleRefresh(): void {
    if (this.refreshTimer) {
      clearTimeout(this.refreshTimer);
    }
    this.refreshTimer = setTimeout(() => void this.refresh(), 250);
  }

  /** Refresh now; a refresh requested during one runs once more afterwards. */
  refresh(): Promise<void> {
    if (this.refreshing) {
      this.refreshAgain = true;
      return this.refreshing;
    }
    this.refreshing = this.doRefresh().finally(() => {
      this.refreshing = undefined;
      if (this.refreshAgain) {
        this.refreshAgain = false;
        void this.refresh();
      }
    });
    return this.refreshing;
  }

  private async doRefresh(): Promise<void> {
    try {
      const [status, prompt, bookmarks, subrepos] = await Promise.all([
        this.oxy.status(this.root),
        this.oxy.prompt(this.root),
        this.oxy.bookmarks(this.root).catch(() => [] as BookmarkInfo[]),
        this.oxy.submodules(this.root).catch(() => [] as SubrepoInfo[]),
      ]);
      this.latest = status;
      this.bookmarksLatest = bookmarks;
      this.subreposLatest = subrepos;
      this.subreposGroup.resourceStates = subrepos.map((s) => new SubrepoState(this, s));
      const conflicted = new Set(status.conflicts.map((c) => c.path).filter((p): p is string => !!p));
      const conflicts: OxyResourceState[] = [];
      const changes: OxyResourceState[] = [];
      for (const p of status.paths) {
        const state = new OxyResourceState(this, p.path, p.status);
        if (p.status === "ConflictEdited" || p.status === "Resolved" || conflicted.has(p.path)) {
          conflicts.push(state);
        } else {
          changes.push(state);
        }
      }
      // Conflicted files the working copy has not touched yet still need resolving.
      for (const c of status.conflicts) {
        if (c.path && !status.paths.some((p) => p.path === c.path)) {
          conflicts.push(new OxyResourceState(this, c.path, "ConflictEdited"));
        }
      }
      this.conflictsGroup.resourceStates = conflicts;
      this.changesGroup.resourceStates = changes;
      this.sourceControl.count = status.paths.length + (status.conflicts.length ? status.conflicts.length : 0);
      this.updateStatusBar(status, prompt);
      this.onDidChangeStatusEmitter.fire(status);
    } catch (e) {
      this.statusBar.text = "$(warning) oxy";
      this.statusBar.tooltip = String(e);
      this.statusBar.show();
    }
  }

  private updateStatusBar(status: StatusInfo, prompt: string): void {
    if (!vscode.workspace.getConfiguration("oxygen").get<boolean>("statusBar.enabled", true)) {
      this.statusBar.hide();
      return;
    }
    const text = prompt || `${status.bookmark} ${status.working_copy.slice(0, 8)}`;
    // The bookmark in the Oxygen accent when clean, amber with uncommitted
    // work, and on the error background with conflicts.
    const dirty = status.paths.length > 0;
    this.statusBar.text = `$(${status.conflicted ? "warning" : "bookmark"}) ${text}`;
    this.statusBar.color = status.conflicted ? undefined : new vscode.ThemeColor(dirty ? "oxygen.warning" : "oxygen.accent");
    this.statusBar.tooltip = new vscode.MarkdownString(
      `**Oxygen** ${basename(this.root)}\n\n` +
        `Bookmark \`${status.bookmark}\` with ${status.heads} head${status.heads === 1 ? "" : "s"}\n\n` +
        (status.conflicted ? `$(warning) The state has conflicts\n\n` : "") +
        `${status.paths.length} changed path${status.paths.length === 1 ? "" : "s"}`,
      true,
    );
    this.statusBar.backgroundColor = status.conflicted ? new vscode.ThemeColor("statusBarItem.errorBackground") : undefined;
    this.statusBar.show();
    const current = this.currentBookmark;
    if (current && (current.ahead !== null || current.behind !== null)) {
      const ahead = current.ahead ?? 0;
      const behind = current.behind ?? 0;
      this.syncBar.text = `$(cloud-upload) ${ahead} $(cloud-download) ${behind}`;
      this.syncBar.color = new vscode.ThemeColor(behind > 0 ? "oxygen.pull" : ahead > 0 ? "oxygen.push" : "oxygen.good");
      this.syncBar.tooltip = `${ahead} change${ahead === 1 ? "" : "s"} to push, ${behind} to pull from origin. Click to sync.`;
      this.syncBar.show();
    } else {
      this.syncBar.hide();
    }
  }

  // QuickDiffProvider: the base version of a file, served from oxy.
  provideOriginalResource(uri: vscode.Uri): vscode.Uri | undefined {
    const rel = this.relativePath(uri);
    if (!rel) {
      return undefined;
    }
    const status = this.latest?.paths.find((p) => p.path === rel)?.status;
    if (status === "Added") {
      return undefined;
    }
    return baseUri(this.root, rel);
  }

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