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 read = (file) => JSON.parse(fs.readFileSync(path.join(root, file), "utf8"));
const sha256File = (file) => crypto.createHash("sha256").update(fs.readFileSync(path.join(root, file))).digest("hex");
const record = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
const stableJSON = (value) => {
  if (Array.isArray(value)) return `[${value.map(stableJSON).join(",")}]`;
  if (record(value)) return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJSON(value[key])}`).join(",")}}`;
  return JSON.stringify(value);
};
const sha256Value = (value) => crypto.createHash("sha256").update(stableJSON(value)).digest("hex");
const checkArtifact = (artifact) => assert.equal(sha256File(artifact.path), artifact.sha256, artifact.path);

const evidence = read("tests/golden/M12-01/evidence.json");
assert.equal(evidence.task, "M12-01I");
assert.equal(evidence.status, "READY");
assert.equal(evidence.enablingTask, true);
assert.equal(evidence.parityStateChange, false);
assert.equal(evidence.nextTask, "M12-02A");
assert.equal(evidence.subtasks.length, 8);

const taskNames = evidence.subtasks.map((entry) => entry.task);
assert.deepEqual(taskNames, ["M12-01A", "M12-01B", "M12-01C", "M12-01D", "M12-01E", "M12-01F", "M12-01G", "M12-01H"]);
evidence.subtasks.forEach((entry, index) => {
  checkArtifact(entry);
  const manifest = read(entry.path);
  assert.equal(manifest.task, entry.task);
  assert.equal(manifest.enablingTask, true);
  assert.equal(manifest.parityStateChange, false);
  assert.equal(manifest.nextTask, index === evidence.subtasks.length - 1 ? "M12-01I" : evidence.subtasks[index + 1].task);
  if (Array.isArray(manifest.sources)) manifest.sources.forEach(checkArtifact);
  if (record(manifest.artifacts)) Object.values(manifest.artifacts).forEach(checkArtifact);
});

Object.values(evidence.schema).forEach(checkArtifact);
for (const key of ["sourceFixture", "targetFixture", "report", "productionProtocol"]) checkArtifact(evidence.migration[key]);
for (const key of ["indexedDB", "restartWorker"]) checkArtifact(evidence.runtime[key]);

const source = read(evidence.migration.sourceFixture.path);
const target = read(evidence.migration.targetFixture.path);
const report = read(evidence.migration.report.path);
assert.equal(source.schemaVersion, 1);
assert.equal(target.schemaVersion, 2);
assert.equal(source.revision, evidence.migration.revision);
assert.equal(target.revision, evidence.migration.revision);
assert.equal(sha256Value(source), evidence.migration.sourceManifestSha256);
assert.equal(sha256Value(target), evidence.migration.targetManifestSha256);
assert.equal(report.sourceManifestSha256, evidence.migration.sourceManifestSha256);
assert.equal(report.targetManifestSha256, evidence.migration.targetManifestSha256);
assert.equal(report.sourceRevision, evidence.migration.revision);
assert.equal(report.targetRevision, evidence.migration.revision);
assert.equal(report.preserved.catalogs, evidence.runtime.catalogCount);
assert.equal(report.preserved.assets, evidence.runtime.assetCount);

const restart = read("tests/golden/M12-01H/manifest.json").restart;
assert.deepEqual(restart.catalogOrder, target.catalogs.map((catalog) => catalog.catalogId));
assert.deepEqual(restart.assetOrder, target.assets.map((asset) => asset.assetId));
assert.equal(restart.manifestSha256, evidence.migration.targetManifestSha256);
assert.deepEqual(restart.contexts, evidence.runtime.restartContexts);
assert.deepEqual(read("tests/golden/M12-01G/manifest.json").transaction.faultPoints, evidence.runtime.faultPoints);

process.stdout.write(`asset-catalog-m12-evidence-ok subtasks=${evidence.subtasks.length} catalogs=${evidence.runtime.catalogCount} assets=${evidence.runtime.assetCount} next=${evidence.nextTask}\n`);