import assert from "node:assert/strict";
import crypto from "node:crypto";
import fs from "node:fs";
import path from "node:path";
import { fileURLToPath } from "node:url";

const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
const abs = (file) => path.join(root, file);
const read = (file) => JSON.parse(fs.readFileSync(abs(file), "utf8"));
const sha256 = (file) => crypto.createHash("sha256").update(fs.readFileSync(abs(file))).digest("hex");
const manifest = read("tests/golden/WBV2/internal-submodule-smoke-manifest.json");
const plan = read(manifest.plan.path);
const report = read(manifest.report.path);
const focused = read(manifest.focusedFixReport.path);
const regression = read(manifest.regressionReport.path);

assert.equal(plan.operation, "ONE_PASS_INTERNAL_SUBMODULE_SMOKE");
assert.equal(plan.policy.oneSmokePerSubmodule, true);
assert.equal(plan.policy.retryFailedSubmodule, false);
assert.equal(plan.cases.length, 101);
assert.equal(new Set(plan.cases.map((item) => item.submoduleId)).size, plan.cases.length);
assert.equal(new Set(plan.cases.map((item) => item.smokeId)).size, plan.cases.length);
assert.ok(plan.cases.every((item) => item.runOnce === true && item.maxAttempts === 1));
assert.equal(report.cases.length, plan.cases.length);
assert.ok(report.cases.every((item) => item.attempts === 1));
assert.equal(report.summary.attempts, plan.cases.length);
assert.equal(report.summary.retries, 0);

const initialPassed = report.cases.filter((item) => item.status === "PASS");
const initialFailed = report.cases.filter((item) => item.status !== "PASS");
assert.deepEqual(
  focused.fixes.map((item) => item.submoduleId).sort(),
  initialFailed.map((item) => item.submoduleId).sort(),
  "focused verification must contain exactly the initial smoke failures",
);
assert.ok(focused.fixes.every((item) => item.verificationAttempt === 1));
assert.equal(focused.summary.retries, 0);
const focusedPassed = focused.fixes.filter((item) => item.status === "PASS");
const focusedFailed = focused.fixes.filter((item) => item.status !== "PASS");
assert.deepEqual(focusedFailed.map((item) => item.submoduleId), ["addModifier"]);
assert.equal(regression.submoduleId, "addModifier");
assert.equal(regression.status, "PASS");
assert.equal(regression.verificationAttempts, 1);
assert.equal(regression.retries, 0);
assert.equal(regression.input.modifierType, "SUBSURF");
assert.equal(regression.addedModifier.type, "SUBSURF");

const resolvedIds = new Set([
  ...initialPassed.map((item) => item.submoduleId),
  ...focusedPassed.map((item) => item.submoduleId),
  regression.submoduleId,
]);
assert.equal(resolvedIds.size, plan.cases.length);
assert.equal(manifest.status, "pass");
assert.deepEqual(manifest.summary, {
  totalSubmodules: 101,
  smokeAttempts: 101,
  initialPassed: 92,
  initialFailed: 9,
  focusedFixPassed: 8,
  regressionPassed: 1,
  resolved: 101,
  blocked: 0,
  retries: 0,
  remainingBlocker: null,
});
for (const item of [manifest.plan, manifest.report, manifest.focusedFixReport, manifest.regressionReport, manifest.planDocument, manifest.reusedNlaEvidence, manifest.sourceSyncReceipt, manifest.currentArtifact.wasm, manifest.currentArtifact.loader]) {
  assert.equal(sha256(item.path), item.sha256, `submodule smoke artifact hash mismatch: ${item.path}`);
}
const sourceSync = read(manifest.sourceSyncReceipt.path);
assert.equal(sourceSync.status, "PASS");
assert.equal(sourceSync.artifacts.wasmSha256, manifest.currentArtifact.wasm.sha256);
assert.equal(sourceSync.artifacts.loaderSha256, manifest.currentArtifact.loader.sha256);
process.stdout.write(`wbv2-submodule-smoke-plan-ok submodules=101 attempts=101 initialPassed=92 focusedFixPassed=8 regressionPassed=1 resolved=101/101 blocked=0 retries=0\n`);