// Minimal reproduction for the @electric-sql/pglite `_pg_initdb` WASM trap
// ("unreachable") that crashes the AWS Blocks dev server right after the
// "AWS Blocks local server running" banner.
//
// It boots a FRESH PGlite instance per cycle (as DsqlMockEngine does in its
// constructor: `new PGlite(dataDir)`) and issues the first query, which is
// exactly what `runMigrations` does first ("CREATE TABLE IF NOT EXISTS
// _migrations ..."). PGlite lazily runs `_pg_initdb` on that first query — the
// trap site. We hammer it N times sequentially and M in parallel, since the
// crash is intermittent (surfaces under CI memory/concurrency pressure).
//
// Run:  node repro.mjs [SEQ=30] [PAR=8]
import { PGlite } from '@electric-sql/pglite';
import { mkdtempSync, rmSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';

const SEQ = Number(process.argv[2] ?? 30);
const PAR = Number(process.argv[3] ?? 8);

// The exact first two statements runMigrations issues (bb-distributed-data).
const MIGRATIONS_DDL = `
  CREATE TABLE IF NOT EXISTS _migrations (
    id TEXT PRIMARY KEY DEFAULT gen_random_uuid(),
    name TEXT NOT NULL UNIQUE,
    applied_at TIMESTAMP NOT NULL DEFAULT NOW()
  )
`;

async function bootAndMigrateOnce(label) {
  const dir = mkdtempSync(join(tmpdir(), 'pglite-repro-'));
  const db = new PGlite(dir); // DsqlMockEngine ctor does exactly this
  try {
    await db.query(MIGRATIONS_DDL); // first query → triggers _pg_initdb
    await db.query('SELECT name FROM _migrations ORDER BY name');
    return { label, ok: true };
  } finally {
    try { await db.close(); } catch {}
    try { rmSync(dir, { recursive: true, force: true }); } catch {}
  }
}

const isUnreachable = (e) => /unreachable/i.test(String(e?.message ?? e)) || /unreachable/i.test(String(e?.stack ?? ''));

let failures = 0;
console.log(`[repro] pglite _pg_initdb stress — ${SEQ} sequential + ${PAR} parallel boots`);

for (let i = 0; i < SEQ; i++) {
  try {
    await bootAndMigrateOnce(`seq#${i}`);
    process.stdout.write('.');
  } catch (e) {
    failures++;
    console.error(`\n[repro] SEQ boot #${i} FAILED (unreachable=${isUnreachable(e)}):\n`, e?.stack ?? e);
  }
}
process.stdout.write('\n');

const settled = await Promise.allSettled(
  Array.from({ length: PAR }, (_, i) => bootAndMigrateOnce(`par#${i}`)),
);
for (const r of settled) {
  if (r.status === 'rejected') {
    failures++;
    console.error(`[repro] PAR boot FAILED (unreachable=${isUnreachable(r.reason)}):\n`, r.reason?.stack ?? r.reason);
  }
}

if (failures === 0) {
  console.log(`[repro] OK — ${SEQ + PAR} boots, no _pg_initdb trap on this host.`);
  process.exit(0);
} else {
  console.error(`[repro] REPRODUCED — ${failures}/${SEQ + PAR} boots crashed in _pg_initdb.`);
  process.exit(1);
}

// Automated regression test for the @electric-sql/pglite `_pg_initdb` WASM trap
// ("QueryFailedException: unreachable") observed on CI, crashing the AWS Blocks
// dev server during runMigrations' first query.
//
// The test boots many FRESH PGlite instances — sequentially and in parallel —
// each issuing the first migration query (the `_pg_initdb` trigger). It asserts
// that NONE trap with "unreachable". When the bug is present the test FAILS
// (or flakes); when PGlite inits cleanly it passes.
//
// Run:  node --test pglite-initdb.test.mjs
//   Tune stress via env: SEQ (default 40), PAR (default 12), ROUNDS (default 3).
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { PGlite } from '@electric-sql/pglite';
import { mkdtempSync, rmSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';

const SEQ = Number(process.env.SEQ ?? 40);
const PAR = Number(process.env.PAR ?? 12);
const ROUNDS = Number(process.env.ROUNDS ?? 3);

const MIGRATIONS_DDL = `
  CREATE TABLE IF NOT EXISTS _migrations (
    id TEXT PRIMARY KEY DEFAULT gen_random_uuid(),
    name TEXT NOT NULL UNIQUE,
    applied_at TIMESTAMP NOT NULL DEFAULT NOW()
  )
`;

const isUnreachable = (e) =>
  /unreachable/i.test(String(e?.message ?? e)) || /unreachable/i.test(String(e?.stack ?? ''));

async function bootAndMigrateOnce() {
  const dir = mkdtempSync(join(tmpdir(), 'pglite-test-'));
  const db = new PGlite(dir); // mirrors DsqlMockEngine constructor
  try {
    await db.query(MIGRATIONS_DDL);                                  // first query → _pg_initdb
    await db.query('SELECT name FROM _migrations ORDER BY name');    // runMigrations' next query
  } finally {
    try { await db.close(); } catch {}
    try { rmSync(dir, { recursive: true, force: true }); } catch {}
  }
}

async function runGuarded() {
  try {
    await bootAndMigrateOnce();
    return null;
  } catch (e) {
    return e;
  }
}

test(`PGlite _pg_initdb never traps 'unreachable' across ${SEQ} sequential boots`, async () => {
  const crashes = [];
  for (let i = 0; i < SEQ; i++) {
    const err = await runGuarded();
    if (err) crashes.push({ i, unreachable: isUnreachable(err), stack: err?.stack ?? String(err) });
  }
  assert.deepEqual(
    crashes.filter(c => c.unreachable),
    [],
    `PGlite _pg_initdb trapped 'unreachable':\n${crashes.map(c => `seq#${c.i}: ${c.stack}`).join('\n\n')}`,
  );
  assert.equal(crashes.length, 0, `Non-unreachable failures:\n${crashes.map(c => c.stack).join('\n\n')}`);
});

test(`PGlite _pg_initdb never traps 'unreachable' across ${ROUNDS}×${PAR} parallel boots`, async () => {
  const crashes = [];
  for (let r = 0; r < ROUNDS; r++) {
    const settled = await Promise.allSettled(Array.from({ length: PAR }, () => bootAndMigrateOnce()));
    settled.forEach((s, i) => {
      if (s.status === 'rejected') {
        crashes.push({ r, i, unreachable: isUnreachable(s.reason), stack: s.reason?.stack ?? String(s.reason) });
      }
    });
  }
  assert.deepEqual(
    crashes.filter(c => c.unreachable),
    [],
    `PGlite _pg_initdb trapped 'unreachable':\n${crashes.map(c => `round${c.r}/par#${c.i}: ${c.stack}`).join('\n\n')}`,
  );
  assert.equal(crashes.length, 0, `Non-unreachable failures:\n${crashes.map(c => c.stack).join('\n\n')}`);
});