import { describe, expect, it } from "vitest";

import {
  decodeToolcraftModelDocument,
  encodeToolcraftModelDocument,
  ToolcraftModelDocumentCodecError,
  type ToolcraftModelDocumentCodecFailureCode,
} from "./model-document-codec";
import { createModelNode, createValidModelDocument } from "./model-document-test-support";

const MEBIBYTE = 1024 * 1024;
const METADATA_DESCRIPTOR_LENGTH_OFFSET = 16 + 8;
const PAYLOAD_OFFSET = 16 + 4 * 16;

function expectCodecFailure(
  operation: () => unknown,
  code: ToolcraftModelDocumentCodecFailureCode,
): void {
  try {
    operation();
    throw new Error("Expected canonical codec operation to fail.");
  } catch (error) {
    expect(error).toBeInstanceOf(ToolcraftModelDocumentCodecError);
    expect(error).toMatchObject({ code });
  }
}

function prefixMetadataWithBom(encoded: Uint8Array): Uint8Array {
  const view = new DataView(
    encoded.buffer,
    encoded.byteOffset,
    encoded.byteLength,
  );
  const metadataLength = Number(
    view.getBigUint64(METADATA_DESCRIPTOR_LENGTH_OFFSET, true),
  );
  const rewritten = new Uint8Array(encoded.byteLength + 3);

  rewritten.set(encoded.subarray(0, PAYLOAD_OFFSET));
  rewritten.set([0xef, 0xbb, 0xbf], PAYLOAD_OFFSET);
  rewritten.set(encoded.subarray(PAYLOAD_OFFSET), PAYLOAD_OFFSET + 3);
  new DataView(rewritten.buffer).setBigUint64(
    METADATA_DESCRIPTOR_LENGTH_OFFSET,
    BigInt(metadataLength + 3),
    true,
  );
  return rewritten;
}

describe("canonical codec encode/decode closure", () => {
  it("round-trips 700k ASCII metadata under a one MiB envelope limit", () => {
    const name = "a".repeat(700_000);
    const document = createValidModelDocument({
      nodes: [createModelNode({ name })],
    });
    const limits = {
      maxDecodedBytes: MEBIBYTE,
      maxEstimatedWorkerBytes: 64 * MEBIBYTE,
    };

    const encoded = encodeToolcraftModelDocument(document, limits);

    expect(encoded.byteLength).toBeLessThan(MEBIBYTE);
    expect(decodeToolcraftModelDocument(encoded, limits).nodes[0]?.name).toBe(
      name,
    );
  });

  it("rejects the same metadata when worker memory is insufficient", () => {
    const document = createValidModelDocument({
      nodes: [createModelNode({ name: "a".repeat(700_000) })],
    });
    const sufficientLimits = {
      maxDecodedBytes: MEBIBYTE,
      maxEstimatedWorkerBytes: 64 * MEBIBYTE,
    };
    const narrowLimits = {
      maxDecodedBytes: MEBIBYTE,
      maxEstimatedWorkerBytes: 8 * MEBIBYTE,
    };
    const encoded = encodeToolcraftModelDocument(document, sufficientLimits);

    expectCodecFailure(
      () => encodeToolcraftModelDocument(document, narrowLimits),
      "estimated-worker-memory-limit-exceeded",
    );
    expectCodecFailure(
      () => decodeToolcraftModelDocument(encoded, narrowLimits),
      "estimated-worker-memory-limit-exceeded",
    );
  });

  it("rejects encode when multibyte metadata would exceed decode memory", () => {
    const document = createValidModelDocument({
      nodes: [createModelNode({ name: "é".repeat(300_000) })],
    });
    const looseLimits = {
      maxDecodedBytes: MEBIBYTE,
      maxEstimatedWorkerBytes: 64 * MEBIBYTE,
    };
    const boundaryLimits = {
      maxDecodedBytes: MEBIBYTE,
      maxEstimatedWorkerBytes: 20 * MEBIBYTE,
    };
    const encoded = encodeToolcraftModelDocument(document, looseLimits);

    expectCodecFailure(
      () => decodeToolcraftModelDocument(encoded, boundaryLimits),
      "estimated-worker-memory-limit-exceeded",
    );
    expectCodecFailure(
      () => encodeToolcraftModelDocument(document, boundaryLimits),
      "estimated-worker-memory-limit-exceeded",
    );
  });

  it("rejects BOM-prefixed alternate metadata bytes", () => {
    const encoded = encodeToolcraftModelDocument(createValidModelDocument());

    expectCodecFailure(
      () => decodeToolcraftModelDocument(prefixMetadataWithBom(encoded)),
      "non-canonical-metadata",
    );
  });
});