import assert from "node:assert/strict";
import fs from "node:fs";
import os from "node:os";
import path from "node:path";
import { pathToFileURL } from "node:url";
import test from "node:test";
import ts from "typescript";

const root = path.resolve(import.meta.dirname, "../../..");
const temporary = fs.mkdtempSync(path.join(os.tmpdir(), "ply-import-unit-"));
const sourcePath = path.join(root, "web/protocol/ply-import.ts");
const transpiled = ts.transpileModule(fs.readFileSync(sourcePath, "utf8"), { compilerOptions: { module: ts.ModuleKind.ES2022, target: ts.ScriptTarget.ES2022 }, fileName: sourcePath, reportDiagnostics: true });
assert.deepEqual(transpiled.diagnostics, []);
const modulePath = path.join(temporary, "ply-import.mjs");
fs.writeFileSync(modulePath, transpiled.outputText);
const protocol = await import(pathToFileURL(modulePath));
const fixtureRoot = path.join(root, "tests/files/web/m12_ply_mapping_v1");
const bytes = (name) => { const value = fs.readFileSync(path.join(fixtureRoot, name)); return value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength); };

test("M12-07H maps ASCII and binary little-endian PLY fields", () => {
  const ascii = protocol.importPLY(bytes("mapping-ascii.ply"), { format: "ascii" });
  const binary = protocol.importPLY(bytes("mapping-binary-le.ply"), { format: "binary_little_endian" });
  assert.equal(ascii.vertices.length, 4);
  assert.equal(ascii.faces.length, 2);
  assert.deepEqual(ascii.vertices[0].position, [-1, 0, 1]);
  assert.deepEqual(ascii.vertices[0].normal, [0, 1, 0]);
  assert.deepEqual(ascii.vertices[0].color, [254 / 255, 0, 0, 1]);
  assert.deepEqual(ascii.vertices[3].customProperties, { label: 4, temperature: 40 });
  assert.deepEqual(binary.vertices, ascii.vertices);
  assert.deepEqual(binary.faces, ascii.faces);
  assert.deepEqual(protocol.createPLYLossReport(ascii), { schemaVersion: 1, operation: "PLY_IMPORT_LOSS_REPORT", canImport: true, warningCount: 0, warnings: [] });
});

test("M12-07H reports unknown list properties without dropping mapped fields", () => {
  const imported = protocol.importPLY(bytes("unknown-property-ascii.ply"), { format: "ascii" });
  assert.equal(imported.vertices.length, 4);
  assert.equal(imported.vertices[0].customProperties.temperature, 10);
  assert.deepEqual(protocol.createPLYLossReport(imported).warnings.map((warning) => warning.code), ["PLY_UNKNOWN_PROPERTY"]);
  assert.equal(protocol.createPLYLossReport(imported).warnings[0].property, "unknown_values");
});

test("M12-07H serializes mapped data and rejects an explicit format mismatch", () => {
  const document = protocol.importPLY(bytes("mapping-ascii.ply"));
  const output = protocol.serializePLYAscii(document);
  const reopened = protocol.importPLY(output, { format: "ascii" });
  assert.deepEqual(reopened.faces, document.faces);
  assert.deepEqual(reopened.vertices.map((vertex) => vertex.customProperties), document.vertices.map((vertex) => vertex.customProperties));
  assert.throws(() => protocol.importPLY(bytes("mapping-ascii.ply"), { format: "binary_little_endian" }), /PLY_FORMAT_MISMATCH/);
});

test.after(() => fs.rmSync(temporary, { recursive: true, force: true }));