// 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 4: drop()/cancelRead() on a handle whose readable end has been
// transferred to a guest. Does the stale host handle still act on the shared
// object the guest now owns?
import { caught, errStr, fixture, guest, show, streamsMod, timeout, turn, unhandled } from "./h.ts";
const { Stream } = streamsMod;

async function scenario(label: string, act: (stale: InstanceType<typeof Stream>) => void) {
  const c = await fixture(guest("stream-echo"), {}, { jspi: false });
  const { stream: src, writer } = Stream.create<number>();
  // Guest-created stream (lifted, host holds its readable end).
  const out1 = await c.exports.echoDoubled(src);
  // Hand out1 back to the guest: guest now owns out1's readable end, and
  // produces out2 from it. The host's `out1` facade is stale (#162 transfer).
  const out2 = await c.exports.echoDoubled(out1);
  const staleRead = errStr(await caught(() => out1.read(1)));
  const w = writer.writeAll([1, 2]);
  const first = await out2.read(1);
  show(label + " first out2 chunk", first);
  await w;
  // Host acts on the STALE handle.
  act(out1);
  await turn();
  const w2 = writer.writeAll([3]);
  const second = await timeout(out2.read(1), 300);
  show(label + " out2 after acting on stale handle", second);
  show(label + " writer.writeAll([3]) settled", await timeout(w2, 300));
  const third = await timeout(out2.read(1), 300);
  show(label + " out2 third read (expect [12])", third);
  show(label + " stale read refusal", staleRead);
  out2.drop();
  src.drop();
  await turn();
}

await scenario("drop()", (s) => s.drop());
await scenario("[Symbol.dispose]", (s) => s[Symbol.dispose]());
await scenario("control(no-op)", () => {});

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

// Probe 4c: Future.drop() on a stale lifted handle whose readable end was
// transferred to a guest that is parked reading it. The host never held the
// writable end, yet drop() abandons the future "as the writer" and the guest
// reader traps (poisoning its instance).
//
// Producer: future-disposal `idle()` (guest-created future<u32>, never
// written). Consumer: future-user `doubleFuture(f)` (parks on future.read).
// Two fixtures = two stores; cross-store lowering is accepted today (#344).
// The drop path under test (`HostFuture.drop` -> abandonSharedFuture when
// `lowering.lowered && !delivered`) is store-independent; the only artifact
// is that the consumer's store must be nudged to deliver the event.
import { emb, errStr, fixture, guest, show, timeout, turn, unhandled } from "./h.ts";

for (const mode of ["drop-stale", "control"]) {
  const producer = await fixture(emb("future-disposal"), {}, { jspi: false });
  const consumer = await fixture(guest("future-user"), {}, { jspi: false });
  const f = producer.exports.idle(); // lifted Future<u32>, never written
  await turn();
  const p = consumer.exports.doubleFuture(f); // guest parks on future.read
  const outcome = p.then(
    (v: unknown) => "resolved " + v,
    (e: unknown) => "rejected " + errStr(e),
  );
  await turn();
  if (mode === "drop-stale") f.drop(); // host holds NO end of this future now
  await turn();
  let nudge: string;
  try {
    const g = consumer.exports.makeFuture(0);
    nudge = "ok";
    g.drop();
  } catch (e) {
    nudge = "threw " + errStr(e);
  }
  show(mode + " doubleFuture(stale f)", await timeout(outcome, 300));
  show(mode + " later export call on consumer", nudge);
  await turn();
}
show("unhandled", unhandled);

// Probe 4d (single store): the natural `using`-style pattern — pass a lifted
// future to a guest export, then dispose the (now stale) host handle
// synchronously in the same turn.
import { errStr, fixture, guest, show, timeout, turn, unhandled } from "./h.ts";

for (const mode of ["drop-stale", "control"]) {
  const c = await fixture(guest("future-user"), {}, { jspi: false });
  const f = c.exports.makeFuture(1); // guest-created future; guest writes 2 later
  await turn(); // let the export call materialize f (deferred -> lifted)
  const p = c.exports.doubleFuture(f); // guest parks on future.read
  if (mode === "drop-stale") f.drop(); // host no longer holds any end of f
  const r = await timeout(
    p.then((v: unknown) => "resolved " + v, (e: unknown) => "rejected " + errStr(e)),
    500,
  );
  show(mode + " doubleFuture(f)", r);
  let after: string;
  try {
    const g = c.exports.makeFuture(5);
    after = "ok " + (await timeout(Promise.resolve(g).then((v: unknown) => v), 300));
  } catch (e) {
    after = "threw " + errStr(e);
  }
  show(mode + " next export call on the instance", after);
  await turn();
}
show("unhandled", unhandled);