#!/usr/bin/env node
import crypto from "node:crypto";
import fs from "node:fs";
import os from "node:os";
import path from "node:path";
import { Worker } from "node:worker_threads";
import { execFileSync } from "node:child_process";
import { pathToFileURL } from "node:url";

const root = "/home/mes123456/FreeCADWasmDev/working/FreeCAD";
const build = path.resolve(process.argv[2] ?? path.join(root, "freecad-source/build-web/assembly-configure/bin"));
const batchPath = path.join(root, "docs/current/module-batch-manifest.json");
const batch = JSON.parse(fs.readFileSync(batchPath, "utf8"));
if (batch.status !== "ready" || batch.taskId !== "FW-P6-FPA-Y" || batch.selected?.module !== "Assembly"
  || batch.selected?.tier !== "tier-1-readonly" || batch.selected?.family !== "view-resource"
  || !Array.isArray(batch.records) || batch.records.length !== batch.selected.recordCount
  || batch.records.length < batch.minimumRecords || batch.records.length > 32) {
  throw new Error("unexpected Assembly view-resource module batch manifest");
}

const records = batch.records.map(([apiId, name, disposition, sourcePath, sourceLine]) => ({
  apiId,
  name,
  family: batch.selected.family,
  kind: apiId.split(":")[2] || "method",
  sourcePath,
  sourceLine,
  disposition,
}));
const output = fs.mkdtempSync(path.join(os.tmpdir(), "freecad-assembly-view-resource-batch-"));
const hash = (value) => crypto.createHash("sha256").update(JSON.stringify(value)).digest("hex");
const fileHash = (file) => crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex");
const sourceLineHash = (row) => {
  const sourcePath = row.sourcePath ?? row.sourceEntry;
  const sourceFile = path.join(root, "freecad-source", sourcePath);
  if (!sourcePath || !fs.existsSync(sourceFile)) throw new Error(`Assembly source entry is missing: ${sourcePath}`);
  const line = fs.readFileSync(sourceFile, "utf8").split(/\r?\n/)[row.sourceLine - 1];
  if (!line || !line.trim()) throw new Error(`Assembly source line is empty: ${sourcePath}:${row.sourceLine}`);
  return hash(line);
};

execFileSync(path.join(root, "web/node_modules/.bin/tsc"), [
  "--target", "ES2022", "--module", "ESNext", "--moduleResolution", "Bundler", "--strict", "--skipLibCheck",
  "--outDir", output, "--declaration", "false", "--noEmit", "false",
  path.join(root, "web/src/facade-envelope.ts"), path.join(root, "web/src/assembly-python-family-facade.ts"),
], { cwd: root, stdio: "inherit" });

const facade = await import(pathToFileURL(path.join(output, "assembly-python-family-facade.js")));
const envelope = await import(pathToFileURL(path.join(output, "facade-envelope.js")));
const worker = new Worker(path.join(root, "tools/assembly-python-family-facade-smoke-worker.mjs"), {
  workerData: {
    buildDirectory: build,
    facadePath: pathToFileURL(path.join(output, "assembly-python-family-facade.js")).href,
    envelopePath: pathToFileURL(path.join(output, "facade-envelope.js")).href,
  },
});
const next = () => new Promise((resolve, reject) => {
  const onMessage = (value) => { worker.off("error", onError); resolve(value); };
  const onError = (error) => { worker.off("message", onMessage); reject(error); };
  worker.once("message", onMessage);
  worker.once("error", onError);
});
const request = (requestId, rows = records, tier = "tier-1-readonly") => facade.createAssemblyPythonFamilyRequest(requestId, rows, tier);
const ready = await next();
worker.postMessage(request("assembly-view-resource-success"));
const success = await next();
worker.postMessage(request("assembly-view-resource-repeat"));
const repeat = await next();
worker.postMessage(request("assembly-view-resource-cross", [{ ...records[0], apiId: "py:BIM:class:Binding" }]));
const cross = await next();
const malformedRequest = request("assembly-view-resource-invalid");
worker.postMessage({ ...malformedRequest, payload: { ...malformedRequest.payload, tier: "tier-unsupported" } });
const malformed = await next();
const cancelRequest = request("assembly-family-cancel-1");
worker.postMessage(cancelRequest);
worker.postMessage(envelope.createCancel("assembly-view-resource-cancel-control", cancelRequest.requestId));
const cancelled = await next();
worker.postMessage({ kind: "reset", requestId: "assembly-view-resource-reset" });
const reset = await next();
await worker.terminate();

if (ready.kind !== "ready" || success.kind !== "result" || repeat.kind !== "result" || cross.kind !== "result"
  || malformed.kind !== "error" || cancelled.kind !== "error" || reset.requestId !== "assembly-view-resource-reset") {
  throw new Error(JSON.stringify({ ready, success, repeat, cross, malformed, cancelled, reset }));
}
const result = success.result;
const terminal = new Set(["exposed", "restricted", "nonportable", "not_implemented"]);
if (result.schema !== "freecad-web-assembly/python-family/v1" || result.module !== "Assembly"
  || result.tier !== "tier-1-readonly" || result.count !== records.length || result.records.length !== records.length
  || result.resourcesReleased !== true) throw new Error("Assembly view-resource result is incomplete");
for (const [index, row] of result.records.entries()) {
  const expected = records[index];
  if (!terminal.has(row.status) || row.status !== "restricted" || row.code !== "gui_dependency_unavailable"
    || row.native !== true || row.resourcesReleased !== true || row.replay !== "native-source-boundary"
    || row.apiId !== expected.apiId || row.name !== expected.name || row.family !== expected.family
    || row.sourceEntry !== expected.sourcePath || row.sourceLine !== expected.sourceLine || row.sourceVerified !== true
    || typeof row.sourceRevision !== "string" || row.parameterSchema !== "source-declared" || row.returnSchema !== "gui-resource") {
    throw new Error(`Assembly view-resource record mismatch: ${expected.apiId}`);
  }
  sourceLineHash(expected);
}
if (JSON.stringify(result) !== JSON.stringify(repeat.result)) throw new Error("Assembly view-resource replay changed native result");
if (cross.result.records?.[0]?.status !== "not_implemented" || cross.result.records?.[0]?.code !== "unmatched_source_record") throw new Error("Assembly view-resource cross-module boundary failed");
if (malformed.error.code !== "invalid_request") throw new Error("Assembly view-resource invalid tier was not rejected");
if (cancelled.error.code !== "cancelled") throw new Error("Assembly view-resource cancellation was not reported");

const evidencePath = `docs/p6/assembly-module-batch-${batch.batchId}-runtime.json`;
const manifestPath = path.join(root, "docs/p6/python-api-manifest.json");
const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
const byId = new Map(result.records.map((row) => [row.apiId, row]));
for (const row of manifest.records) {
  const native = byId.get(row.id);
  if (!native) continue;
  row.disposition = native.status;
  row.dispositionEvidence = [evidencePath];
  row.dispositionReason = native.message;
}
fs.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);

const dispositionCounts = Object.fromEntries([...terminal].map((status) => [status, result.records.filter((row) => row.status === status).length]));
const report = {
  schema: "freecad-web-assembly-module-batch-runtime/v1",
  taskId: "FW-P6-FPA-Y",
  batchId: batch.batchId,
  module: "Assembly",
  tier: "tier-1-readonly",
  family: "view-resource",
  status: "pass_with_boundaries",
  sourceRevision: result.records[0]?.sourceRevision,
  route: { command: "assembly.pythonFamily", native: "freecad-source/src/WebAssembly/FreeCADCoreProbe/AssemblyRuntimeProbe.cpp:fc_web_dispatch_json", facade: "web/src/assembly-python-family-facade.ts", worker: "web/src/assembly.worker.ts" },
  input: { cmd: "assembly.pythonFamily", args: { tier: "tier-1-readonly", records } },
  inputSha256: hash(records),
  result,
  resultSha256: hash(result),
  replay: { equal: true, resultSha256: hash(repeat.result) },
  facadeWorker: { ready, success, repeat, crossModule: cross, malformed, cancelled, reset, traceSha256: hash({ ready, success, repeat, cross, malformed, cancelled, reset }) },
  dispositionCounts,
  records: result.records.map((row) => ({ apiId: row.apiId, name: row.name, family: row.family, status: row.status, code: row.code, message: row.message, sourceEntry: row.sourceEntry, sourceLine: row.sourceLine, sourceVerified: row.sourceVerified, sourceRevision: row.sourceRevision, sourceLineHash: sourceLineHash(row), parameterSchema: row.parameterSchema, returnSchema: row.returnSchema, replay: row.replay, evidenceSha256: hash(row) })),
  resources: { resourcesReleased: result.resourcesReleased, documentMutation: false, headlessBoundaryFixture: true },
  artifacts: { wasm: { path: path.relative(root, path.join(build, "FreeCADWebAssemblyProbe.wasm")), sha256: fileHash(path.join(build, "FreeCADWebAssemblyProbe.wasm")) }, loader: { path: path.relative(root, path.join(build, "FreeCADWebAssemblyProbe.js")), sha256: fileHash(path.join(build, "FreeCADWebAssemblyProbe.js")) } },
  boundaries: ["Assembly view-resource declarations are source-verified and restricted because AssemblyGui/PySide is unavailable in the GUI-free Web kernel.", "No GUI resource or icon result is synthesized in JavaScript; the native fixture proves the boundary and resource release.", "Cross-module records are rejected by the module-scoped adapter; all statuses and hashes derive from compiled FreeCAD through fc_web_dispatch_json."],
};
fs.writeFileSync(path.join(root, evidencePath), `${JSON.stringify(report, null, 2)}\n`);
const logPath = `docs/freecad-p6-assembly-module-batch-${batch.batchId}.log`;
fs.writeFileSync(path.join(root, logPath), `${JSON.stringify({ status: report.status, batchId: report.batchId, count: records.length, dispositionCounts, resultSha256: report.resultSha256 })}\n`);
console.log(JSON.stringify({ status: report.status, batchId: report.batchId, count: records.length, dispositionCounts, resultSha256: report.resultSha256 }));
process.exit(0);