// OxygenFlow in the editor, without VS Code: how runs and jobs look (icon,
// colour, labels) and which runs just finished. Shared by the Flow view, the
// status bar item and the tests.

import type { FlowJob, FlowRun, TestCase } from "./hubapi";

/** A codicon and a theme colour id for a run's or job's status. */
export interface Look {
  /** Codicon id; `~spin` makes it turn. */
  icon: string;
  /** A theme colour id, e.g. `testing.iconPassed`. */
  color: string;
  /** A short word for screen readers and tooltips. */
  word: string;
}

export function look(status: string): Look {
  switch (status) {
    case "passed":
      return { icon: "pass-filled", color: "testing.iconPassed", word: "passed" };
    case "failed":
      return { icon: "error", color: "testing.iconFailed", word: "failed" };
    case "error":
      return { icon: "warning", color: "testing.iconErrored", word: "could not run" };
    case "running":
      return { icon: "sync~spin", color: "oxygenhub.flowRunning", word: "running" };
    case "queued":
      return { icon: "clock", color: "testing.iconQueued", word: "queued" };
    case "skipped":
      return { icon: "debug-step-over", color: "testing.iconSkipped", word: "skipped" };
    default:
      return { icon: "circle-large-outline", color: "descriptionForeground", word: status };
  }
}

export function live(status: string): boolean {
  return status === "queued" || status === "running";
}

/** "3.2 s", "4 min 10 s". */
export function duration(ms: number): string {
  const s = Math.max(0, ms) / 1000;
  if (s < 60) {
    return `${s.toFixed(1)} s`;
  }
  return `${Math.floor(s / 60)} min ${Math.floor(s % 60)} s`;
}

/** "just now", "5 minutes ago", as the hub says it. */
export function ago(ms: number, now = Date.now()): string {
  const s = Math.max(0, Math.floor((now - ms) / 1000));
  const unit = (n: number, w: string) => `${n} ${w}${n === 1 ? "" : "s"} ago`;
  if (s < 45) {
    return "just now";
  }
  if (s < 90) {
    return "a minute ago";
  }
  if (s < 2700) {
    return unit(Math.ceil(s / 60), "minute");
  }
  if (s < 5400) {
    return "an hour ago";
  }
  if (s < 79200) {
    return unit(Math.ceil(s / 3600), "hour");
  }
  return unit(Math.ceil(s / 86400), "day");
}

/** What a run ran on: its bookmark, or the change for a run on one change. */
export function subject(run: FlowRun): string {
  return run.bookmark || `change ${(run.heads[0] ?? "").slice(0, 12)}`;
}

/** "#12 main". */
export function runLabel(run: FlowRun): string {
  return `#${run.number} ${subject(run)}`;
}

/** "passed in 2 min 3 s · push by andy · 5 minutes ago". */
export function runDescription(run: FlowRun, now = Date.now()): string {
  const took = run.finished_ms ? ` in ${duration(run.finished_ms - run.created_ms)}` : "";
  const queued = run.status === "queued" && run.queue_position ? ` (#${run.queue_position} in line)` : "";
  const trigger = run.trigger.startsWith("rerun:") ? `re-run of #${run.trigger.slice(6)}` : run.trigger;
  return `${look(run.status).word}${took}${queued} · ${trigger} by ${run.actor} · ${ago(run.created_ms, now)}`;
}

/**
 * Runs that were live at the last look and are finished now, so the editor
 * can say so once. `before` maps a run's key to its last status.
 */
export function newlyFinished(before: Map<string, string>, runs: { key: string; run: FlowRun }[]): { key: string; run: FlowRun }[] {
  return runs.filter(({ key, run }) => {
    const was = before.get(key);
    return was !== undefined && live(was) && !live(run.status);
  });
}

/** Whether a job waits on someone's approval before it runs (oxygenflow#57). */
export function waitingApproval(job: FlowJob): boolean {
  return job.approval === "waiting" && job.status === "queued";
}

/** MiB as the hub's pages say it: "900 MiB", "2.1 GiB". */
function mib(n: number): string {
  return n >= 1024 ? `${(n / 1024).toFixed(1)} GiB` : `${n} MiB`;
}

/**
 * Where a job's time went (#348): how long it waited for a runner, each
 * phase its runner reported, and its peak disk and memory. Empty when the
 * hub reported none of it.
 */
export function jobTimings(job: FlowJob): string[] {
  const out: string[] = [];
  if (job.queued_ms && job.started_ms) {
    out.push(`waited ${duration(job.started_ms - job.queued_ms)}`);
  }
  for (const p of job.phases ?? []) {
    out.push(`${p.name} ${p.ms < 1000 ? `${p.ms} ms` : duration(p.ms)}`);
  }
  const peaks = [job.peak_disk_mib ? `disk ${mib(job.peak_disk_mib)}` : "", job.peak_memory_mib ? `memory ${mib(job.peak_memory_mib)}` : ""].filter(Boolean);
  if (peaks.length) {
    out.push(`peak ${peaks.join(", ")}`);
  }
  return out;
}

/** A test report's cases by suite, in the order they came, for the Testing view. */
export function casesBySuite(cases: TestCase[]): Map<string, TestCase[]> {
  const out = new Map<string, TestCase[]>();
  for (const c of cases) {
    const suite = c.suite || c.classname || "tests";
    out.set(suite, [...(out.get(suite) ?? []), c]);
  }
  return out;
}

/** A case's id in the Testing view: stable across reports, so its history lines up. */
export function caseId(repo: string, c: TestCase): string {
  return `${repo}::${c.suite || c.classname || "tests"}::${c.classname}::${c.name}`;
}

/** What VS Code should show for a case's status: passed, failed, errored or skipped. */
export function caseOutcome(status: string): "passed" | "failed" | "errored" | "skipped" {
  return status === "passed" ? "passed" : status === "failed" ? "failed" : status === "error" ? "errored" : "skipped";
}