import assert from "node:assert/strict";
import fs from "node:fs";
import path from "node:path";
import test from "node:test";
import ts from "typescript";

const root = path.resolve(import.meta.dirname, "../../..");
const sourcePath = path.join(root, "web/protocol/render-routing.ts");
const source = fs.readFileSync(sourcePath, "utf8").replace('import type { ErrorCode } from "./error";\n', "");
const transpiled = ts.transpileModule(source, {
  compilerOptions: { module: ts.ModuleKind.ES2022, target: ts.ScriptTarget.ES2022 },
  fileName: sourcePath,
  reportDiagnostics: true,
});
assert.deepEqual(transpiled.diagnostics, []);
const routing = await import("data:text/javascript;base64," + Buffer.from(transpiled.outputText).toString("base64"));
const golden = JSON.parse(fs.readFileSync(path.join(root, "tests/golden/M11-05/render-routing.json"), "utf8"));

const request = (overrides = {}) => ({ schemaVersion: 1, renderEngine: "BLENDER_EEVEE", backend: "WEBGL2", complexity: "BOUNDED", ...overrides });

test("M11-05 keeps bounded Eevee on the declared local backend", () => {
  const result = routing.routeRenderExecution(request());
  assert.deepEqual(result, {
    schemaVersion: 1, target: "WEB_LOCAL_BOUNDED", status: "READY", capability: "WEB_REALTIME_BOUNDED", reason: "BOUNDED_EEVEE", issues: [],
  });
  assert.deepEqual({ target: result.target, status: result.status, capability: result.capability, reason: result.reason }, golden.boundedEevee);
  assert.equal(routing.routeRenderExecution(request({ backend: "WEBGPU" }), { webgpuAvailable: true, webgpuRendererBundled: true }).status, "READY");
});

test("M11-05 routes Cycles, complex Eevee and hardware to SERVER_JOB without a local success", () => {
  for (const [candidate, expected] of [
    [request({ renderEngine: "BLENDER_CYCLES", backend: "CYCLES" }), golden.cycles],
    [request({ complexity: "COMPLEX", backend: "EEVEE_COMPLEX" }), golden.complexEevee],
    [request({ hardwareBackend: "OPTIX" }), golden.hardware],
  ]) {
    const result = routing.routeRenderExecution(candidate);
    assert.equal(result.target, expected.target);
    assert.equal(result.status, expected.withoutEndpoint.status);
    assert.equal(result.reason, expected.withoutEndpoint.reason);
    assert.equal(result.issues[0].code, expected.withoutEndpoint.code);
  }
  const available = routing.routeRenderExecution(request({ renderEngine: "BLENDER_CYCLES", backend: "CYCLES" }), { serverRenderAvailable: true });
  assert.deepEqual([available.target, available.status, available.capability], [golden.cycles.target, golden.cycles.withEndpoint.status, golden.cycles.withEndpoint.capability]);
});

test("M11-05 blocks unavailable WebGPU and unknown engines and rejects malformed routes", () => {
  const webgpu = routing.routeRenderExecution(request({ backend: "WEBGPU" }));
  assert.deepEqual([webgpu.target, webgpu.status, webgpu.issues[0].code], [golden.webgpu.target, golden.webgpu.status, golden.webgpu.code]);
  const unknown = routing.routeRenderExecution(request({ renderEngine: "UNKNOWN_ENGINE" }));
  assert.deepEqual([unknown.target, unknown.status, unknown.capability, unknown.issues[0].code], [golden.unknownEngine.target, golden.unknownEngine.status, golden.unknownEngine.capability, golden.unknownEngine.code]);
  assert.throws(() => routing.routeRenderExecution(request({ backend: "INVALID" })), /INVALID_ARGUMENT/);
  assert.throws(() => routing.routeRenderExecution(request({ renderEngine: "invalid engine" })), /INVALID_ARGUMENT/);
});