import { runInNewContext } from "node:vm";

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

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

function expectInvalidInput(value: unknown): void {
  try {
    decodeToolcraftModelDocument(value as Uint8Array);
    throw new Error("Expected hostile codec input to fail.");
  } catch (error) {
    expect(error).toBeInstanceOf(ToolcraftModelDocumentCodecError);
    expect(error).toMatchObject({ code: "invalid-input", path: "bytes" });
  }
}

describe("canonical hostile decode input", () => {
  it.each(["byteLength", "buffer", "byteOffset"] as const)(
    "does not invoke an own %s accessor on a genuine Uint8Array",
    (property) => {
      const encoded = encodeToolcraftModelDocument(createValidModelDocument());
      const get = vi.fn(() => {
        throw new Error(`${property} accessor escaped`);
      });
      Object.defineProperty(encoded, property, { configurable: true, get });

      expect(decodeToolcraftModelDocument(encoded)).toEqual(
        createValidModelDocument(),
      );
      expect(get).not.toHaveBeenCalled();
    },
  );

  it("does not invoke an overridden subarray method", () => {
    const encoded = encodeToolcraftModelDocument(createValidModelDocument());
    const subarray = vi.fn(() => {
      throw new Error("subarray override escaped");
    });
    Object.defineProperty(encoded, "subarray", {
      configurable: true,
      value: subarray,
    });

    expect(decodeToolcraftModelDocument(encoded)).toEqual(
      createValidModelDocument(),
    );
    expect(subarray).not.toHaveBeenCalled();
  });

  it("does not invoke a prototype byteLength accessor", () => {
    const encoded = encodeToolcraftModelDocument(createValidModelDocument());
    const get = vi.fn(() => {
      throw new Error("prototype accessor escaped");
    });
    const prototype = Object.create(Uint8Array.prototype) as object;
    Object.defineProperty(prototype, "byteLength", { get });
    Object.setPrototypeOf(encoded, prototype);

    expect(decodeToolcraftModelDocument(encoded)).toEqual(
      createValidModelDocument(),
    );
    expect(get).not.toHaveBeenCalled();
  });

  it("accepts a genuine cross-realm Uint8Array", () => {
    const encoded = encodeToolcraftModelDocument(createValidModelDocument());
    const foreign = runInNewContext("new Uint8Array(values)", {
      values: [...encoded],
    }) as Uint8Array;

    expect(decodeToolcraftModelDocument(foreign)).toEqual(
      createValidModelDocument(),
    );
  });

  it("rejects spoofed, wrong-kind, proxied, and shared inputs", () => {
    const spoof = Object.assign(Object.create(null) as Record<PropertyKey, unknown>, {
      [Symbol.toStringTag]: "Uint8Array",
      length: 80,
    });
    const wrongKind = new Uint16Array(80);
    const encoded = encodeToolcraftModelDocument(createValidModelDocument());
    const proxied = new Proxy(encoded, {
      getPrototypeOf() {
        throw new Error("proxy trap escaped");
      },
    });
    const shared = new Uint8Array(new SharedArrayBuffer(encoded.length));
    shared.set(encoded);

    for (const input of [spoof, wrongKind, proxied, shared]) {
      expectInvalidInput(input);
    }
  });
});