// Flow's test reports in VS Code's Testing view (spec §9.2): the newest

// report on each repository's current bookmark, its suites and cases with

// their results, messages and output. Nothing runs here: running a test

// loads the hub's latest results.

import * as vscode from "vscode";

import { HubAuth } from "./auth";

import { caseId, caseOutcome, casesBySuite, duration } from "./flowview";

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

export class HubTests implements vscode.Disposable {

  private readonly controller: vscode.TestController;

  constructor(

    private readonly auth: HubAuth,

    private readonly repos: () => Promise<HubRepo[]>,

  ) {

    this.controller = vscode.tests.createTestController("oxygenhub", "OxygenFlow test reports");

    this.controller.refreshHandler = () => this.load();

    this.controller.createRunProfile("Load the hub's latest results", vscode.TestRunProfileKind.Run, () => this.load(), true);

  }

  dispose(): void {

    this.controller.dispose();

  }

  /** Fetch each repository's newest test report and show its results. */

  async load(): Promise<void> {

    const repos = await this.repos().catch(() => [] as HubRepo[]);

    const roots: vscode.TestItem[] = [];

    const results: [vscode.TestItem, string, string, string, number][] = [];

    for (const repo of repos) {

      const client = this.auth.clientFor(repo.base);

      const bookmark = repo.handle.currentBookmark ?? undefined;

      const [newest] = await client.testReports(repo.owner, repo.name, bookmark, 1).catch(() => []);

      if (!newest) {

        continue;

      }

      const detail = await client.testReport(repo.owner, repo.name, newest.id).catch(() => undefined);

      if (!detail) {

        continue;

      }

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

      const r = detail.report;

      const root = this.controller.createTestItem(key, `${repo.owner}/${repo.name}`);

      root.description = `${r.passed}/${r.tests} passed${r.failed ? ` · ${r.failed} failed` : ""} · run #${r.run} ${r.job} on ${r.bookmark}`;

      for (const [suite, cases] of casesBySuite(detail.cases)) {

        const s = this.controller.createTestItem(`${key}::${suite}`, suite);

        for (const c of cases) {

          const item = this.controller.createTestItem(caseId(key, c), c.name);

          item.description = c.classname && c.classname !== suite ? c.classname : undefined;

          s.children.add(item);

          results.push([item, c.status, c.message, c.output, c.time_ms]);

        }

        root.children.add(s);

      }

      roots.push(root);

    }

    this.controller.items.replace(roots);

    const run = this.controller.createTestRun(new vscode.TestRunRequest(), "OxygenFlow", false);

    for (const [item, status, message, output, ms] of results) {

      const outcome = caseOutcome(status);

      if (outcome === "passed") {

        run.passed(item, ms);

      } else if (outcome === "skipped") {

        run.skipped(item);

      } else {

        const m = new vscode.TestMessage(message || `${status} after ${duration(ms)}`);

        if (output) {

          m.actualOutput = output;

        }

        (outcome === "failed" ? run.failed : run.errored).call(run, item, m, ms);

      }

    }

    run.end();

  }

}