import { assert, assertEquals } from "jsr:@std/assert@^1.0.0";

import { RunnerRuntime } from "../../../uptime.link/ts_api/classes/runner-runtime.ts";

const scenarioName = "uptimerunner-vagrant";
const controllerHost = Deno.env.get("UPTIMELINK_CONTROLLER_HOST") ?? "0.0.0.0";
const controllerPort = Number(
  Deno.env.get("UPTIMELINK_CONTROLLER_PORT") ?? "8080",
);
const runnerId = Deno.env.get("UPTIMELINK_RUNNER_ID") ?? "vagrant-runner-1";
const runnerToken = Deno.env.get("UPTIMELINK_RUNNER_TOKEN") ?? "vagrant-token";
const targetPort = Number(Deno.env.get("UPTIMELINK_TARGET_PORT") ?? "18081");
const timeoutMs = Number(
  Deno.env.get("UPTIMELINK_VAGRANT_TIMEOUT_MS") ?? "120000",
);
const targetUrl = Deno.env.get("UPTIMELINK_RUNNER_TARGET_URL") ??
  `http://127.0.0.1:${targetPort}/health`;

const main = async () => {
  const runtime = new RunnerRuntime();
  const coordinator = runtime.coordinator;
  await runtime.registerRunner({
    runnerId,
    token: runnerToken,
    labels: ["scenario:vagrant", "role:internal"],
  });

  coordinator.enqueueCheck({
    id: "vagrant-runner-local-http",
    type: "http",
    url: targetUrl,
    expectedStatusCodes: [200],
    expectedBodyIncludes: "runner-local healthy",
    timeoutMs: 5000,
    metadata: {
      monitorId: "vagrant-runner-local-http",
    },
  }, { runnerId });

  const server = Deno.serve(
    { hostname: controllerHost, port: controllerPort },
    (request) => {
      return runtime.handleRequest(request);
    },
  );

  try {
    console.log(
      `[${scenarioName}] Controller listening on ${controllerHost}:${controllerPort}`,
    );
    console.log(`[${scenarioName}] Waiting for runner ${runnerId}`);

    await waitFor(
      () => coordinator.getRunner(runnerId)?.lastHeartbeat,
      timeoutMs,
    );
    const result = await waitFor(
      () =>
        coordinator.listResults().find((candidate) => {
          return candidate.checkId === "vagrant-runner-local-http";
        }),
      timeoutMs,
    );

    assert(result);
    if (result.status !== "ok") {
      console.error(JSON.stringify(result, null, 2));
    }
    assertEquals(result.runnerId, runnerId);
    assertEquals(result.type, "http");
    assertEquals(result.status, "ok");
    assertEquals(result.statusCode, 200);
    assert(result.responseTime !== undefined);
    assertEquals(coordinator.getQueueLength(), 0);

    console.log(`[${scenarioName}] Passed`);
  } finally {
    await server.shutdown();
  }
};

async function waitFor<T>(
  readArg: () => T | undefined,
  timeoutMsArg: number,
): Promise<T> {
  const started = Date.now();
  while (Date.now() - started < timeoutMsArg) {
    const value = readArg();
    if (value) {
      return value;
    }
    await new Promise((resolve) => setTimeout(resolve, 500));
  }
  throw new Error(`Timed out after ${timeoutMsArg}ms.`);
}

if (import.meta.main) {
  try {
    await main();
  } catch (error) {
    console.error(
      `[${scenarioName}] Failed: ${
        error instanceof Error ? error.stack : String(error)
      }`,
    );
    Deno.exit(1);
  }
}