// Multi-device White Noise groups: one account on two coinos devices, against
// the Rust reference (MDK's `wn`), on public relays with throwaway identities.
//
//   bun tools/marmot-multidevice-test.js
//
// Needs `wn` (github.com/marmot-protocol/mdk, crates/cli) on PATH or at WN,
// with its daemon on public relays:
//   export WN_HOME=… WN_SECRET_STORE=file WN_SOCKET=/tmp/wn.sock
//   wn daemon start --discovery-relays wss://nos.lol,wss://relay.primal.net \
//                   --default-account-relays wss://nos.lol,wss://relay.primal.net
//
// Covers: both devices publish KeyPackages (one slot each); a wn invitation
// reaches whichever device(s) wn adds; a group founded on device A adds
// device B by itself (the admin's sibling add) through our own inbox; wn
// reads and writes a group holding two leaves of one npub; both devices read.
import { spawnSync } from 'node:child_process';
import { finalizeEvent, generateSecretKey, getPublicKey } from 'nostr-tools/pure';
import { npubEncode } from 'nostr-tools/nip19';
// MD_DEBUG=1 shows the client's dlog lines (sibling adds and why they skip)
if (process.env.MD_DEBUG && typeof localStorage === 'undefined') {
  globalThis.localStorage = { getItem: (k) => (k === 'coinos-debug' ? '1' : null), setItem() {}, removeItem() {} };
}
const { marmotClient } = await import('../src/marmot-client.js');
const { subscribeOn, publishOn } = await import('../src/nostr.js');
const { unwrapDM } = await import('../src/dm.js');

const WN = process.env.WN || 'wn';
const RELAYS = (process.env.RELAYS || 'wss://relay.coinos.io,wss://nos.lol,wss://relay.primal.net').split(',');
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
let failed = 0;
const ok = (cond, label, extra) => { if (cond) console.log('  ok  ' + label); else { failed++; console.log('  FAIL ' + label + (extra ? ' — ' + extra : '')); } };
function wn(args, { account } = {}) {
  const r = spawnSync(WN, ['--json', ...(account ? ['--account', account] : []), ...args], { encoding: 'utf8', timeout: 60_000 });
  const line = (r.stdout || '').trim().split('\n').filter(Boolean).at(-1) || '';
  try { const j = JSON.parse(line); return j.ok ? j.result : { error: j.error }; } catch { return { error: { message: (r.stderr || r.stdout || 'no output').trim().slice(0, 300) } }; }
}
const waitFor = async (fn, label, ms = 45_000) => { const t = Date.now(); while (Date.now() - t < ms) { const v = await fn(); if (v) return v; await sleep(1500); } console.log('  … timed out waiting for ' + label); return null; };
const memStore = () => { const m = new Map(); return { all: async () => new Map(m), put: async (k, v) => { m.set(k, structuredClone(v)); }, del: async (k) => { m.delete(k); }, wipe: async () => m.clear() }; };

const who = wn(['whoami']);
if (who.error) { console.log('SKIP: wn daemon not reachable (' + who.error.message + ')'); process.exit(0); }

// one account, two devices
const sk = generateSecretKey(), pk = getPublicKey(sk);
const identity = async () => ({ pubkey: pk, signer: sk });
const log = { A: [], B: [] };
const mk = (name) => marmotClient({
  scope: 'test-' + name, pubkey: pk, identity, relays: RELAYS, store: memStore(),
  on: (type, g, data) => { if (type === 'message') log[name].push(data); if (type === 'joined') console.log(`  [${name}] joined ${g.id.slice(0, 8)} (invited by ${(g.inviter || '').slice(0, 8)})`); },
});
const A = mk('A'), B = mk('B');
// the account's relay lists, so wn can route to us (the sync feature publishes these for a real wallet)
for (const kind of [10002, 10050]) await publishOn(RELAYS, finalizeEvent({ kind, created_at: Math.floor(Date.now() / 1000), tags: RELAYS.map((r) => [kind === 10002 ? 'r' : 'relay', r]), content: '' }, sk));
// the DM inbox: every Welcome for our npub goes to both devices, as the app's inbox does
// no `since`: a gift wrap's created_at is randomized into the past (NIP-59)
subscribeOn(RELAYS, { kinds: [1059], '#p': [pk] }, async (ev) => {
  let got; try { got = await unwrapDM(ev, sk); } catch { return; }
  const rumor = got && got.rumor;
  if (!rumor || rumor.kind !== 444) return;
  for (const c of [A, B]) c.welcome(rumor).catch(() => {});
});

try {
  await A.start(); await B.start();
  ok(await A.ready({ interactive: true }), 'device A published a KeyPackage');
  ok(await B.ready({ interactive: true }), 'device B published a KeyPackage');
  await sleep(2000);
  const mine = await A.lookupAll(pk);
  ok(mine.length === 2 && new Set(mine.map((c) => c.slot)).size === 2, 'the account shows two devices (two slots)', JSON.stringify(mine.map((c) => c.slot.slice(0, 8))));

  // ---- 1. wn invites the account: which devices get in? ----
  const alice = wn(['create-identity']).account_id;
  const check = wn(['keys', 'check', pk]);
  ok(check && !check.error, 'wn finds our relay lists + KeyPackages', JSON.stringify(check).slice(0, 200));
  const made = wn(['groups', 'create', 'multidev', pk], { account: alice });
  ok(!made.error, 'wn created a group with our npub', JSON.stringify(made.error || '').slice(0, 200));
  const wnGroup = made.group_id || made.group?.group_id || made.group_id_hex;
  const joinedCount = await waitFor(async () => { const n = [A, B].filter((c) => [...c.groups.values()].some((g) => !g.removed)).length; return n ? n : null; }, 'a device joins the wn group', 40_000);
  await sleep(6000); // a second Welcome may follow
  const inWn = [A, B].filter((c) => [...c.groups.values()].some((g) => !g.removed)).map((c) => (c === A ? 'A' : 'B'));
  console.log('  wn invited devices:', inWn.join(',') || 'none', '(MDK adds', inWn.length, 'of our 2 KeyPackages)');
  ok(inWn.length >= 1, 'at least one device joined the wn group');

  // ---- 2. our group: device A founds it, invites wn, and adds device B on its own ----
  const g = await A.create({ name: 'two devices', members: [alice] }) // account_id is the hex pubkey.catch((e) => { console.log('  create failed:', e.message); return null; });
  ok(!!g, 'device A founded a group with the wn account');
  if (g) {
    await A.siblingAdds();
    const gB = await waitFor(async () => [...B.groups.values()].find((x) => x.id === g.id && !x.removed) || null, 'device B joins through the sibling add');
    ok(!!gB, 'device B joined device A\'s group from our own inbox');
    if (gB) {
      ok(gB.inviter === pk, 'the Welcome came from our own account', gB.inviter && gB.inviter.slice(0, 8));
      B.accept(gB);
      ok(A.accounts(g).length === 2 && A.accounts(g).includes(pk), 'two accounts, three leaves', `accounts=${A.accounts(g).length}`);
    }
    // wn joins and must still work with two leaves of one npub in the tree
    const seen = await waitFor(async () => JSON.stringify(wn(['chats', 'list'], { account: alice })).includes(g.id) || JSON.stringify(wn(['groups', 'invites'], { account: alice })).includes(g.id) || null, 'wn sees our group');
    ok(!!seen, 'wn received the Welcome to our group');
    wn(['groups', 'accept', g.id], { account: alice });
    await sleep(3000);
    const show = wn(['groups', 'show', g.id], { account: alice });
    console.log('  wn groups show:', JSON.stringify(show).slice(0, 400));
    const posted = wn(['messages', 'send', g.id, 'hello both devices'], { account: alice });
    ok(!posted.error, 'wn sent into the three-leaf group', JSON.stringify(posted.error || ''));
    ok(!!await waitFor(async () => log.A.some((m) => m.content === 'hello both devices') || null, 'A reads wn'), 'device A reads wn');
    ok(!!await waitFor(async () => log.B.some((m) => m.content === 'hello both devices') || null, 'B reads wn'), 'device B reads wn');
    if (gB) {
      ok(await B.send(gB, B.event(9, 'from device B', [])), 'device B sent');
      ok(!!await waitFor(async () => JSON.stringify(wn(['messages', 'list', g.id, '--limit', '20'], { account: alice })).includes('from device B') || null, 'wn reads B'), 'wn reads device B');
      ok(!!await waitFor(async () => log.A.some((m) => m.content === 'from device B') || null, 'A reads B'), 'device A reads device B');
    }
    ok(await A.send(g, A.event(9, 'from device A', [])), 'device A sent');
    ok(!!await waitFor(async () => JSON.stringify(wn(['messages', 'list', g.id, '--limit', '20'], { account: alice })).includes('from device A') || null, 'wn reads A'), 'wn reads device A');
  }
  console.log(failed ? `\n${failed} FAILED` : '\nMULTI-DEVICE OK');
} catch (e) { console.log('\nCRASH', e.stack || e.message); failed++; }
finally { A.stop(); B.stop(); await sleep(500); process.exit(failed ? 1 : 0); }