// Shared harness for the embedder-handles adversarial track.
// Run from the repo root:
//   deno run --config runtime/deno.json --allow-read --allow-env=POLYENGINE_SCHED_SEED <script>
const REPO = "<REPO>/";
export const root = REPO;

export const { instantiate } = await import(
  REPO + "runtime/src/embedder/mod.ts"
);
export const { Translator } = await import(REPO + "runtime/src/shim/mod.ts");
export const streamsMod = await import(REPO + "runtime/src/embedder/streams.ts");
export const hostStreamsMod = await import(
  REPO + "runtime/src/exec/host_streams.ts"
);
export const taskMod = await import(REPO + "runtime/src/task/mod.ts");

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

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

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

export const emb = (name: string) => `runtime/tests/embedder/${name}.wasm`;
export const guest = (name: string) =>
  `examples/guests/build/${name}.component.wasm`;

export const unhandled: string[] = [];
export const unhandledStacks: string[] = [];
globalThis.addEventListener("unhandledrejection", (ev) => {
  ev.preventDefault();
  const reason = (ev as PromiseRejectionEvent).reason;
  unhandled.push(String(reason));
  unhandledStacks.push(
    reason instanceof Error ? (reason.stack ?? "") : String(reason),
  );
});

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

export function timeout<T>(p: Promise<T>, ms = 200): Promise<T | "TIMEOUT"> {
  return Promise.race([
    p,
    new Promise<"TIMEOUT">((r) => setTimeout(() => r("TIMEOUT"), ms)),
  ]);
}

export function show(label: string, v: unknown) {
  console.log(label + ":", typeof v === "string" ? v : JSON.stringify(v));
}

export const errStr = (e: unknown) =>
  e instanceof Error ? `${e.name}: ${e.message}` : String(e);

// Probe 6: Promise future sources settling after the guest dropped its
// readable end; thenable-of-thenable; own payload after drop; detached u8.
import { caught, emb, errStr, fixture, show, streamsMod, timeout, turn, unhandled } from "./h.ts";
const { Stream } = streamsMod;

class R {
  static disposed = 0;
  [Symbol.dispose]() {
    R.disposed++;
  }
}

// A. Promise rejects after the guest dropped the readable end.
{
  const c = await fixture(emb("future-own"), { r: R }, { jspi: false });
  let rej!: (e: unknown) => void;
  const p = new Promise<R>((_, r) => rej = r);
  await c.exports.drop(p); // guest drops the readable end immediately
  rej(new Error("late rejection"));
  await turn();
  const next = await caught(() => c.exports.drop(Promise.resolve(new R())));
  show("A next export after late rejection", errStr(next));
  await turn();
  const again = await caught(() => c.exports.drop(Promise.resolve(new R())));
  show("A next-next export", errStr(again));
}

// B. Promise resolves to own<R> after the guest dropped the readable end: disposed exactly once?
{
  R.disposed = 0;
  const c = await fixture(emb("future-own"), { r: R }, { jspi: false });
  let res!: (v: R) => void;
  const p = new Promise<R>((r) => res = r);
  await c.exports.drop(p);
  res(new R());
  await turn();
  await turn();
  show("B own payload after reader drop: disposed", R.disposed);
}

// C. Promise resolving to a thenable that resolves to a Future handle.
{
  const c = await fixture(emb("busy-read"), {}, { jspi: false });
  // Not directly observable via busy-read; just make sure nothing explodes.
  const inner = c.exports.passFuture(Promise.resolve(7));
  const outer = Promise.resolve({ then: (ok: (v: unknown) => void) => ok(inner) });
  const back = await c.exports.passFuture(outer);
  show("C nested thenable -> future value", await timeout(Promise.resolve(back).then((v) => v, (e) => "rejected " + errStr(e))));
}

// D. StreamWriter.write(Uint8Array) then detach the buffer before the rendezvous.
{
  const c = await fixture(emb("busy-read"), {}, { jspi: false });
  const { stream, writer } = Stream.create<number>();
  const back = await c.exports.passStream(stream);
  const buf = new Uint8Array([1, 2, 3, 4]);
  const w = writer.write(buf);
  buf.buffer.transfer(); // detach
  // Guest peer read (sync export doing an async canon read: rendezvous immediately).
  const r = await caught(() => c.exports.readStream(back));
  show("D guest read after detach", errStr(r) === "undefined" ? "ok" : errStr(r));
  show("D write outcome", await timeout(w.then((n) => "resolved " + n, (e) => "rejected " + errStr(e))));
  const ping = await caught(() => c.exports.ping());
  show("D instance still healthy (ping)", errStr(ping) === "undefined" ? "ok" : errStr(ping));
}

await turn();
show("unhandled", unhandled);