#!/usr/bin/env node

const assert = require("assert");
const cp = require("child_process");
const fs = require("fs");
const path = require("path");

const repo = path.resolve(__dirname, "..");

function runReport(mode, env = {}) {
  const output = cp.execFileSync(
    "node",
    ["scripts/acceptance-report.js", mode],
    {
      cwd: repo,
      encoding: "utf8",
      env: { ...process.env, ...env },
    }
  );
  const report = JSON.parse(output);
  const persistedPath = path.join(
    repo,
    "target",
    "acceptance",
    `${mode}-environment.json`
  );
  const persisted = JSON.parse(fs.readFileSync(persistedPath, "utf8"));
  assert.deepStrictEqual(persisted, report, `${mode} report was not persisted`);
  return report;
}

function assertString(value, name) {
  assert.strictEqual(typeof value, "string", `${name} must be a string`);
  assert(value.length > 0, `${name} must not be empty`);
}

function assertNullableString(value, name) {
  if (value === null) return;
  assertString(value, name);
}

function assertPodmanReport(podman) {
  assert(podman && typeof podman === "object", "podman report must be an object");
  assert(
    ["available", "incomplete"].includes(podman.status),
    "podman.status must be available or incomplete"
  );
  assertNullableString(podman.version, "podman.version");
  assertNullableString(podman.rootless, "podman.rootless");
  assertNullableString(podman.incomplete_reason, "podman.incomplete_reason");
  if (podman.status === "available") {
    assertString(podman.version, "podman.version");
    assert.strictEqual(podman.rootless, "true");
    assert.strictEqual(podman.incomplete_reason, null);
  } else {
    assertString(podman.incomplete_reason, "podman.incomplete_reason");
  }
}

function assertReport(report, mode, expectedWindowsValidation) {
  assert.strictEqual(report.kind, "disasmer_acceptance_environment");
  assert.strictEqual(report.mode, mode);
  assert.match(report.generated_at, /^\d{4}-\d{2}-\d{2}T/);
  assert.match(report.commit, /^[0-9a-f]{40}$/);
  assert(Array.isArray(report.tree_status), "tree_status must be an array");

  assertString(report.os.platform, "os.platform");
  assertString(report.os.release, "os.release");
  assertString(report.os.kernel, "os.kernel");
  assertString(report.os.arch, "os.arch");

  assertString(report.rust.rustc, "rust.rustc");
  assertString(report.rust.cargo, "rust.cargo");
  assertString(report.node.version, "node.version");
  assert(report.node.version.startsWith("v"), "node.version must be Node.js style");

  assertPodmanReport(report.podman);
  assertNullableString(report.postgres.version, "postgres.version");
  assertNullableString(report.browser_harness.version, "browser_harness.version");
  assertNullableString(report.browser_harness.command, "browser_harness.command");
  assertString(report.browser_harness.configured, "browser_harness.configured");

  assert(Array.isArray(report.vscode_harness.smokes), "vscode smokes must be listed");
  assert(
    report.vscode_harness.smokes.includes("scripts/vscode-extension-smoke.js"),
    "VS Code extension smoke must be recorded"
  );
  assert(
    report.vscode_harness.smokes.includes("scripts/vscode-f5-smoke.js"),
    "VS Code F5 smoke must be recorded"
  );
  assertString(report.vscode_harness.engine, "vscode_harness.engine");
  assertString(
    report.vscode_harness.extension_version,
    "vscode_harness.extension_version"
  );

  assert.strictEqual(report.windows_validation, expectedWindowsValidation);
}

for (const mode of ["public", "private"]) {
  assertReport(runReport(mode), mode, "not-run");
}

assertReport(
  runReport("windows", {
    DISASMER_WINDOWS_VALIDATION: "forgejo-windows-runner",
  }),
  "windows",
  "forgejo-windows-runner"
);

console.log("Acceptance report smoke passed");