// 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);

// F-candidate: #wrapExportFn / #lowerParams never tear down stream/future
// arguments when the call fails before entering the guest: (a) a later
// parameter fails to lower; (b) the instance is poisoned (entry refusal).
// The ReadableStream stays locked with a pump parked forever; the Promise
// future source is adopted by an orphan writer.
import { caught, embed, fixture, raceTimeout, show, turn } from "./support.ts";

class R {
  [Symbol.dispose]() {}
}
async function make(jspi: boolean) {
  return await fixture(embed("host-settlement"), {
    r: R,
    make: () => new R(),
    makeSync: () => new R(),
    producers: { sources: () => { throw new Error("unused"); } },
    consume: (s: { drop(): void }, f: { drop(): void }) => { s.drop(); f.drop(); return 0; },
  }, { jspi });
}

function src() {
  let cancelled = 0;
  let pulls = 0;
  const rs = new ReadableStream<Uint8Array>({
    pull(ctl) {
      pulls++;
      ctl.enqueue(new Uint8Array([1, 2, 3]));
    },
    cancel() {
      cancelled++;
    },
  });
  return { rs, state: () => ({ locked: rs.locked, cancelled, pulls }) };
}

for (const jspi of [false, true]) {
  const tag = jspi ? "jspi" : "plain";
  {
    // Control: a valid call — the guest consumes; stream is used, then released.
    const c = await make(jspi);
    const { rs, state } = src();
    const r = await raceTimeout(
      Promise.resolve(c.exports.consume(rs, Promise.resolve(7), 0)).then(
        (v) => "resolved:" + v,
        (e) => "rejected:" + show(e),
      ),
      500,
    );
    await turn(); await turn();
    console.log(`[${tag}] control consume(rs, p, 0) [host import drops both]:`, r, JSON.stringify(state()));
  }
  {
    // (a) later-parameter lowering failure after the stream/future were lowered.
    const c = await make(jspi);
    const { rs, state } = src();
    const e = await caught(() => c.exports.consume(rs, Promise.resolve(7), "junk"));
    await turn();
    await turn();
    console.log(`[${tag}] consume(rs, p, "junk") threw:`, show(e));
    console.log(`[${tag}]   source after failure:`, JSON.stringify(state()), "(expected locked:false or cancelled:1)");
    const reuse = await caught(() => rs.getReader());
    console.log(`[${tag}]   rs.getReader() ->`, reuse === undefined ? "ok" : show(reuse));
  }
  {
    // (b) entry refusal on a poisoned instance, after the args were lowered.
    const c = await make(jspi);
    const t = await caught(() => c.exports.trap());
    console.log(`[${tag}] trap() ->`, show(t));
    const { rs, state } = src();
    const e = await caught(() => c.exports.consume(rs, Promise.resolve(7), 0));
    await turn();
    await turn();
    console.log(`[${tag}] consume on poisoned instance threw:`, show(e));
    console.log(`[${tag}]   source after refusal:`, JSON.stringify(state()), "(expected locked:false or cancelled:1)");
  }
}

// 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 1: partial parameter lowering failure on an export call.
// A stream/future arg lowered BEFORE a later arg fails conversion. What
// happens to the stream handle / pump / source?
import { caught, emb, errStr, fixture, show, timeout, turn, unhandled, streamsMod } from "./h.ts";

const { Stream } = streamsMod;

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

async function make() {
  return await fixture(emb("host-settlement"), {
    r: R,
    make: () => new R(),
    makeSync: () => new R(),
    producers: { sources: () => { throw new Error("unused"); } },
    consume: () => 0,
  }, {});
}

// --- Case A: Stream handle (created) lowered, then `mode: u32` fails.
{
  const c = await make();
  const { stream, writer } = Stream.create<number>();
  const e = await caught(() => c.exports.consume(stream, Promise.resolve(1), "bad"));
  show("A call error", errStr(e));
  // The handle was never delivered to a guest. Can the host still read it?
  const r = await caught(() => stream.read(1));
  show("A read after failed call", errStr(r));
  const w = timeout(writer.write([1, 2, 3]));
  show("A writer.write after failed call", await w);
  const pass = await caught(() => c.exports.consume(stream, Promise.resolve(1), 0));
  show("A retry passing same handle", errStr(pass));
}

// --- Case B: ReadableStream source lowered (pump started, reader locked), then mode fails.
{
  const c = await make();
  let cancelled = 0;
  const src = new ReadableStream<number[]>({
    start(ctl) {
      ctl.enqueue([1, 2]);
    },
    cancel() {
      cancelled++;
    },
  });
  const e = await caught(() => c.exports.consume(src, Promise.resolve(1), "bad"));
  show("B call error", errStr(e));
  await turn();
  await turn();
  show("B source", { locked: src.locked, cancelled });
}

// --- Case C: Promise future source lowered, then mode fails; promise later rejects.
{
  const c = await make();
  let rej!: (e: unknown) => void;
  const p = new Promise<number>((_, r) => rej = r);
  const e = await caught(() => c.exports.consume([1], p, "bad"));
  show("C call error", errStr(e));
  rej(new Error("late producer failure"));
  await turn();
  await turn();
  const ping = await caught(() => c.exports.ping());
  show("C ping after orphaned future rejected", errStr(ping) || "ok");
}

// --- Case D: Stream handle then a still-deferred Future (refused loudly).
{
  const c = await fixture(emb("future-disposal"), {}, {});
  const c2 = await make();
  const deferred = c.exports.run(); // Future<u32>, deferred until the export completes
  const { stream } = Stream.create<number>();
  const e = await caught(() => c2.exports.consume(stream, deferred, 0));
  show("D call error", errStr(e));
  const r = await caught(() => stream.read(1));
  show("D read on stream after refusal", errStr(r));
  deferred.drop();
}

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

// --- Case E: import RESULT lowering — record { stream, future } where the
// future member is refused after the stream member's pump started.
{
  const fd = await fixture(emb("future-disposal"), {}, {});
  const deferred = fd.exports.run();
  let cancelled = 0;
  const src = new ReadableStream<number[]>({
    start(ctl) { ctl.enqueue([1]); },
    cancel() { cancelled++; },
  });
  const c = await fixture(emb("host-settlement"), {
    r: R,
    make: () => new R(),
    makeSync: () => new R(),
    producers: { sources: () => ({ stream: src, future: deferred }) },
    consume: () => 0,
  }, {});
  const e = await caught(() => c.exports.sources(0));
  show("E sources() call error", errStr(e));
  await turn(); await turn();
  show("E source", { locked: src.locked, cancelled });
  show("E ping after", errStr(await caught(() => c.exports.ping())));
  // deno-lint-ignore no-explicit-any
  show("E store.hostFailure", errStr((c as any).handle.componentInstances[0].store.hostFailure));
  deferred.drop();
}
await turn();
show("unhandled(final)", unhandled);