// Shared fixture plumbing for the export-drivers adversarial track.
// Mirrors runtime/tests/embedder/support.ts but with absolute repo paths.
export const REPO = "<REPO>/";
import { Translator } from "<REPO>/runtime/src/shim/mod.ts";
import {
  type EmbedderOptions,
  instantiate,
} from "<REPO>/runtime/src/embedder/mod.ts";

const shim = await Deno.readFile(
  REPO + "target/wasm32-unknown-unknown/release/translator_shim.wasm",
);
export const translator = await Translator.create(shim);

export async function artifactsOf(rel: string) {
  const componentBytes = await Deno.readFile(REPO + rel);
  const { plan, adapters } = translator.translate(componentBytes);
  return { plan, componentBytes, adapters };
}

export async function fixture(
  rel: string,
  imports: Record<string, unknown> = {},
  opts: EmbedderOptions = {},
  // deno-lint-ignore no-explicit-any
): Promise<any> {
  return await instantiate(await artifactsOf(rel), imports, opts);
}

export const guest = (n: string) => `examples/guests/build/${n}.component.wasm`;
export const embed = (n: string) => `runtime/tests/embedder/${n}.wasm`;
export const turn = () => new Promise<void>((r) => setTimeout(r, 0));
export const micro = () => Promise.resolve();
export async function caught(f: () => unknown): Promise<unknown> {
  try {
    await f();
  } catch (e) {
    return e;
  }
  return undefined;
}
export function raceTimeout<T>(p: Promise<T>, ms: number): Promise<T | "TIMEOUT"> {
  return Promise.race([
    p,
    new Promise<"TIMEOUT">((r) => setTimeout(() => r("TIMEOUT"), ms)),
  ]);
}
export const show = (e: unknown) =>
  e instanceof Error ? `${e.name}: ${e.message.split("\n")[0].slice(0, 160)}` : String(e);

// hostFailure is a single slot written with `=` (boundary.ts:1891, :1898):
// two async host-import settlements failing in one microtask batch lose the
// first failure; the export awaiting it hangs forever with no diagnostic.
import { Translator } from "<REPO>/runtime/src/shim/mod.ts";
import { instantiate } from "<REPO>/runtime/src/embedder/mod.ts";
import { raceTimeout, REPO, show, turn } from "./support.ts";

const shim = await Deno.readFile(REPO + "target/wasm32-unknown-unknown/release/translator_shim.wasm");
const translator = await Translator.create(shim);
const componentBytes = await Deno.readFile("/tmp/opencode/hb-review/export-drivers/two-inst.wasm");

function deferred<T>() {
  let resolve!: (v: T) => void, reject!: (e: unknown) => void;
  const promise = new Promise<T>((res, rej) => { resolve = res; reject = rej; });
  return { promise, resolve, reject };
}
async function make(jspi: boolean, hx: () => unknown, hy: () => unknown = () => 1) {
  const { plan, adapters } = translator.translate(componentBytes);
  // deno-lint-ignore no-explicit-any
  return await instantiate({ plan, adapters, componentBytes }, { hostX: hx, hostY: hy }, { jspi }) as any;
}
const tag = (p: Promise<unknown>) =>
  raceTimeout(p.then((v) => "resolved:" + JSON.stringify(v), (e) => "rejected:" + show(e)), 400);

for (const jspi of [false, true]) {
  const m = jspi ? "jspi" : "plain";
  console.log(`\n===== ${m} =====`);
  {
    // Control: ONE rejecting import -> its export rejects with a Trap naming it.
    const d = deferred<number>();
    const c = await make(jspi, () => d.promise);
    const p = c.exports.xCallHost();
    const t = tag(p);
    await turn();
    d.reject(new Error("boom-x"));
    console.log("control single rejection:", await t);
  }
  {
    // Same instance, two concurrent calls of one export, both imports reject
    // in the same batch.
    const ds: ReturnType<typeof deferred<number>>[] = [];
    const c = await make(jspi, () => { const d = deferred<number>(); ds.push(d); return d.promise; });
    const p1 = c.exports.xCallHost(), p2 = c.exports.xCallHost();
    const t1 = tag(p1), t2 = tag(p2);
    await turn();
    ds[0].reject(new Error("boom-1"));
    ds[1].reject(new Error("boom-2"));
    console.log("same-instance call#1:", await t1);
    console.log("same-instance call#2:", await t2);
    console.log("  xPing afterwards:", await tag(c.exports.xPing()));
  }
  {
    // Two instances, one store, one rejection each in the same batch.
    const dx = deferred<number>(), dy = deferred<number>();
    const c = await make(jspi, () => dx.promise, () => dy.promise);
    const px = c.exports.xCallHost(), py = c.exports.yCallHost();
    const tx = tag(px), ty = tag(py);
    await turn();
    dx.reject(new Error("boom-x"));
    dy.reject(new Error("boom-y"));
    console.log("two-instance x:", await tx);
    console.log("two-instance y:", await ty);
  }
  {
    // Sequential control: settle one turn apart -> both surface.
    const dx = deferred<number>(), dy = deferred<number>();
    const c = await make(jspi, () => dx.promise, () => dy.promise);
    const px = c.exports.xCallHost(), py = c.exports.yCallHost();
    const tx = tag(px), ty = tag(py);
    await turn();
    dx.reject(new Error("boom-x"));
    await turn();
    dy.reject(new Error("boom-y"));
    console.log("sequential control x:", await tx);
    console.log("sequential control y:", await ty);
  }
}

// Shared fixture plumbing for the import-boundary review probes.
// Run from the repo root:
//   deno run --config runtime/deno.json --allow-read --allow-env=POLYENGINE_SCHED_SEED <script>
export const REPO = "<REPO>/";
import { Translator } from "<REPO>/runtime/src/shim/mod.ts";
import {
  type EmbedderOptions,
  instantiate,
} from "<REPO>/runtime/src/embedder/mod.ts";

const shim = await Deno.readFile(
  REPO + "target/wasm32-unknown-unknown/release/translator_shim.wasm",
);
export const translator = await Translator.create(shim);

export async function fixture(
  rel: string,
  imports: Record<string, unknown>,
  opts: EmbedderOptions = {},
) {
  const componentBytes = await Deno.readFile(REPO + rel);
  const { plan, adapters } = translator.translate(componentBytes);
  return await instantiate({ plan, adapters, componentBytes }, imports, opts);
}

export const turn = () => new Promise<void>((r) => setTimeout(r, 0));
export const micro = () => Promise.resolve();

export async function caught(f: () => unknown): Promise<unknown> {
  try {
    await f();
  } catch (e) {
    return e;
  }
  return undefined;
}

export function describeErr(e: unknown): string {
  if (e === undefined) return "<none>";
  if (e instanceof Error) return `${e.name}: ${e.message.slice(0, 160)}`;
  return String(e);
}

export function guest(name: string): string {
  return `examples/guests/build/${name}.component.wasm`;
}

// F4: store.hostFailure = e overwrites an unconsumed failure; the first fault is lost.
// P14: two late host failures in one turn — is the first lost?
import { caught, describeErr, fixture, turn } from "./support.ts";
import { Future, Stream } from "<REPO>/runtime/src/embedder/streams.ts";
import { hostFuture } from "<REPO>/runtime/src/exec/host_streams.ts";

class R { [Symbol.dispose]() {} }
const FIX = "runtime/tests/embedder/host-settlement.wasm";
const p1 = Promise.withResolvers<unknown>();
const p2 = Promise.withResolvers<unknown>();
const c = await fixture(FIX, {
  r: R,
  make: () => p1.promise,
  makeSync: () => new R(),
  producers: { sources: () => { throw new Error("unused"); } },
  consume: () => p2.promise,
});
const store = c.handle.componentInstances[0].store;
console.log("start:", await c.exports.start(0));
const { stream } = Stream.create<number>();
const fw = hostFuture<number>({ kind: "u32" });
const future = Future.fromHostFuture(fw, { element: { kind: "u32" }, toHost: (v: unknown) => v as number, fromHost: (v: number) => v });
console.log("consume:", await c.exports.consume(stream, future, 0));
console.log("pendingHostCalls:", store.pendingHostCalls.size);
p1.reject(new Error("FAILURE-ONE (make)"));
p2.reject(new Error("FAILURE-TWO (consume)"));
await turn();
console.log("hostFailure after both:", describeErr(store.hostFailure));
console.log("ping #1:", describeErr(await caught(() => c.exports.ping())));
console.log("ping #2:", describeErr(await caught(() => c.exports.ping())));
console.log("finish (waits on make's subtask):", await Promise.race([
  caught(() => c.exports.finish()).then(describeErr),
  new Promise((r) => setTimeout(() => r("TIMEOUT 500ms"), 500)),
]));