import assert from "node:assert/strict";
import test from "node:test";

import {
  ARUSNAVI_B2_MODEL_PROFILE,
  ARUSNAVI_INTERNAL_SPECIFICATION_REF,
  assertB2ProfileInvariant,
  buildB2HeaderAcknowledgement,
  buildB2PackageAcknowledgement,
  buildB2TypedCommand,
  tryParseB2Header2,
  tryParseB2Package,
  tryParseB2TypedCommandResponse,
} from "../src/index.mjs";

const specificationHeader = Buffer.from(
  "FF23E9EF782DE7120300",
  "hex",
);
const specificationPackage = Buffer.from(
  "5B01010000FBDEC251EC5D",
  "hex",
);

test("records the official B2 route, framing and identity evidence", () => {
  assert.equal(assertB2ProfileInvariant(), true);
  assert.equal(ARUSNAVI_B2_MODEL_PROFILE.monitoringServerSlots, 4);
  assert.equal(ARUSNAVI_B2_MODEL_PROFILE.protocol, "INTERNAL");
  assert.equal(ARUSNAVI_B2_MODEL_PROFILE.serverIdentity.kind, "imei");
  assert.equal(
    ARUSNAVI_B2_MODEL_PROFILE.framing.specificationRef,
    ARUSNAVI_INTERNAL_SPECIFICATION_REF,
  );
  assert.equal(
    ARUSNAVI_B2_MODEL_PROFILE.routeCompatibility.gelios,
    "parallel-preserved",
  );
});

test("parses the official HEADER2 example as a claimed IMEI", () => {
  assert.equal(
    tryParseB2Header2(specificationHeader.subarray(0, 9)).status,
    "incomplete",
  );
  const parsed = tryParseB2Header2(specificationHeader);
  assert.equal(parsed.status, "complete");
  assert.equal(parsed.bytesConsumed, 10);
  assert.equal(parsed.identifier.kind, "imei");
  assert.equal(parsed.identifier.value, "865209039777769");
  assert.equal(parsed.identifier.trust, "claimed-not-ownership-proof");
  assert.deepEqual(parsed.evidence, {
    transport: "tcp",
    bytesObserved: 10,
    framingStatus: "verified",
    specificationRef: ARUSNAVI_INTERNAL_SPECIFICATION_REF,
  });
});

test("builds the official HEADER2 acknowledgement example", () => {
  assert.equal(
    buildB2HeaderAcknowledgement(0x52db95de).toString("hex").toUpperCase(),
    "7B0400A0DE95DB527D",
  );
});

test("parses and acknowledges the official package example", () => {
  assert.equal(
    tryParseB2Package(specificationPackage.subarray(0, -1)).status,
    "incomplete",
  );
  const parsed = tryParseB2Package(specificationPackage);
  assert.equal(parsed.status, "complete");
  assert.equal(parsed.bytesConsumed, specificationPackage.length);
  assert.equal(parsed.packageNumber, 1);
  assert.equal(parsed.packetCount, 1);
  assert.equal(parsed.messageType, "telemetry.package");
  assert.equal(
    parsed.payloadSchemaRef,
    "arusnavi.internal.package-metadata.v1",
  );
  assert.deepEqual(parsed.payload, {
    packageNumber: 1,
    packetCount: 1,
    byteLength: specificationPackage.length,
    packageDigest:
      "sha256:bba7205d2f613ac3dfdb7bccdee292b3837e1c8d3d1254ee68bba2dda3853e11",
  });
  assert.equal(
    buildB2PackageAcknowledgement(1).toString("hex").toUpperCase(),
    "7B00017D",
  );
});

test("uses packet lengths and checksum instead of scanning for 0x5D", () => {
  const packetData = Buffer.from([0x5d]);
  const unixTime = Buffer.from([0x01, 0x00, 0x00, 0x00]);
  const checksum = (0x01 + 0x5d) & 0xff;
  const packageBytes = Buffer.from([
    0x5b,
    0x02,
    0x01,
    packetData.length,
    0x00,
    ...unixTime,
    ...packetData,
    checksum,
    0x5d,
  ]);
  const parsed = tryParseB2Package(packageBytes);
  assert.equal(parsed.status, "complete");
  assert.equal(parsed.bytesConsumed, packageBytes.length);
  assert.equal(parsed.packageNumber, 2);
  assert.equal(parsed.packetCount, 1);
  assert.equal(parsed.messageType, "telemetry.package");
  assert.equal(parsed.payload.byteLength, packageBytes.length);
  assert.match(parsed.payload.packageDigest, /^sha256:[a-f0-9]{64}$/);
});

test("fails closed on unsupported headers and malformed packages", () => {
  assert.throws(
    () => tryParseB2Header2(Buffer.from("FE23E9EF782DE7120300", "hex")),
    /b2_header_start_invalid/,
  );
  assert.throws(
    () => tryParseB2Header2(Buffer.from("FF24E9EF782DE7120300", "hex")),
    /b2_header_version_unsupported/,
  );
  const badChecksum = Buffer.from(specificationPackage);
  badChecksum[badChecksum.length - 2] ^= 0xff;
  assert.throws(
    () => tryParseB2Package(badChecksum),
    /b2_packet_checksum_invalid/,
  );
});

test("exports only the typed service-ping command", () => {
  assert.equal(
    ARUSNAVI_B2_MODEL_PROFILE.commandTransport.status,
    "typed-service-ping-v1",
  );
  assert.equal(
    ARUSNAVI_B2_MODEL_PROFILE.commandTransport.exportedCommandBuilders,
    1,
  );
  assert.equal(
    buildB2TypedCommand({ commandType: "service.ping", accessCode: "123456" })
      .toString("ascii"),
    "123456*SERV*1.1",
  );
  assert.deepEqual(
    tryParseB2TypedCommandResponse(Buffer.from("SERV OK", "ascii"), {
      commandType: "service.ping",
    }),
    { status: "acknowledged", bytesConsumed: 7, resultCode: "serv_ok" },
  );
  assert.throws(
    () => buildB2TypedCommand({ commandType: "service.ping", accessCode: "12345" }),
    /b2_command_access_code_invalid/,
  );
  assert.throws(
    () => buildB2TypedCommand({ commandType: "firmware.update", accessCode: "123456" }),
    /b2_typed_command_unsupported/,
  );
});