"""
`MeshBayTransport.rewrapAllNodes` — the passphrase-change / recovery fan-out
(docs/MESHBAY_DESIGN.md §3.6).

The real function is run under node with its two boundaries stubbed: the hub
HTTP calls and the per-node `MeshBayTransport` handshake. What is exercised is
the orchestration — which groups land in `updated` / `unreachable` / `failed`,
which nodes get a `keypair_bundle_store`, and that Flow B also writes a
recovery-wrapped copy. The WebRTC handshake itself and `connect()`'s
recovery-copy fallback are integration territory with no harness here.
"""

import json
import shutil
import subprocess
from pathlib import Path

import pytest

STATIC = Path(__file__).resolve().parents[1] / "src" / "meshbay_hub" / "static"
TRANSPORT = STATIC / "transport.js"

pytestmark = pytest.mark.skipif(
    shutil.which("node") is None or not TRANSPORT.exists(),
    reason="node or transport.js is unavailable",
)

_HARNESS = r"""
const fs = require('fs');
global.self = global;
global.window = global;
global.location = { hash: '' };
global.addEventListener = () => {};
global.document = {
  hidden: false, visibilityState: 'visible', addEventListener: () => {},
};
global.localStorage = {
  getItem: () => null, setItem() {}, removeItem() {}, key: () => null, length: 0,
};
// connect() is stubbed on the prototype below, so no WebRTC shim is needed.
global.RTCPeerConnection = function () { throw new Error('connect() not stubbed'); };

eval(fs.readFileSync(process.argv[2], 'utf8'));
const T = window.MeshBayTransport;

let deriveEncCalls = 0;
window.MeshBayKeys = {
  deriveEncryptionKey:   async (p) => { deriveEncCalls++; return { kind: 'enc', p }; },
  deriveEncryptionKeyV1: async (p) => ({ kind: 'encv1', p }),
  deriveRecoveryKey:     async (r) => ({ kind: 'rec',   r }),
  encryptBundleWithKey:  async (_skEd, _skX, key) => 'wrapped:' + key.kind,
};

const b64 = (s) => Buffer.from(s).toString('base64');

const NODES = {
  'n-ok':      { sessionKeys: { skEdB64: b64('ed'), skXB64: b64('x') } },
  'n-fresh':   { newNodeBundle: 'fresh', sessionKeys: { skEdB64: b64('ed'), skXB64: b64('x') } },
  'n-throw':   { throws: 'handshake failed' },
  'n-noident': { sessionKeys: null },
};

const stored = [];
const rewrapOnlySeen = [];
T.prototype.connect = async function (nodeId) {
  this._nodeId = nodeId;
  rewrapOnlySeen.push(this._rewrapOnly === true);
  const s = NODES[nodeId] || {};
  if (s.throws) throw new Error(s.throws);
  this._sessionKeys = s.sessionKeys || null;
  this._newNodeBundle = s.newNodeBundle || null;
  return { ok: true };
};
T.prototype.storeKeypairBundle = async function (enc, rec) {
  stored.push({ nodeId: this._nodeId, enc, rec: rec || null });
};
T.prototype.close = function () {};

const MINE = { groups: [
  { id: 'gA', name: 'a', owner_username: 'ann' },   // normal node
  { id: 'gB', name: 'b', owner_username: 'ann' },   // no online node
  { id: 'gC', name: 'c', owner_username: 'ann' },   // /nodes errors
  { id: 'gD', name: 'd', owner_username: 'ann' },   // connect throws
  { id: 'gE', name: 'e', owner_username: 'ann' },   // fresh identity, nothing stranded
  { id: 'gF', name: 'f', owner_username: 'ann' },   // identity not recovered
] };
const NODES_FOR = {
  gA: { nodes: [{ node_id: 'n-ok' }] },
  gB: { nodes: [] },
  gC: 'ERR',
  gD: { nodes: [{ node_id: 'n-throw' }] },
  gE: { nodes: [{ node_id: 'n-fresh' }] },
  gF: { nodes: [{ node_id: 'n-noident' }] },
};
global.fetch = async (url) => {
  const path = url.replace(/^.*?(\/v1\/)/, '$1');
  if (path === '/v1/groups/mine') return { ok: true, json: async () => MINE };
  const m = path.match(/^\/v1\/groups\/([^/]+)\/nodes$/);
  if (m) {
    const v = NODES_FOR[m[1]];
    if (v === 'ERR') return { ok: false, status: 503 };
    return { ok: true, json: async () => v };
  }
  return { ok: false, status: 404 };
};

const names = (a) => a.map((x) => x.name).sort();

(async () => {
  const A = await T.rewrapAllNodes({
    hubUrl: 'https://h', token: 't', username: 'u', userId: 'uid',
    oldPassphrase: 'old', newPassphrase: 'new',
  });
  const storeA = stored.splice(0);

  const B = await T.rewrapAllNodes({
    hubUrl: 'https://h', token: 't', username: 'u', userId: 'uid',
    newPassphrase: 'new', recoveryKey: 'A RECOVERY MNEMONIC',
  });
  const storeB = stored.splice(0);

  // Flow C — Profile backfill: keep the live passphrase key, just add the
  // recovery copy. No passphrase strings, so deriveEncryptionKey is not called.
  deriveEncCalls = 0;
  const C = await T.rewrapAllNodes({
    hubUrl: 'https://h', token: 't', username: 'u', userId: 'uid',
    bundleKey: { v2: { kind: 'bk' }, v1: { kind: 'bkv1' } },
    recoveryKey: 'A RECOVERY MNEMONIC',
  });
  const storeC = stored.splice(0);

  process.stdout.write(JSON.stringify({
    a_updated: names(A.updated),
    a_unreachable: names(A.unreachable),
    a_failed: names(A.failed),
    a_stored_nodes: storeA.map((s) => s.nodeId).sort(),
    a_recovery_always_null: storeA.every((s) => s.rec === null),
    a_new_bundle_key_kind: A.newBundleKey && A.newBundleKey.v2 && A.newBundleKey.v2.kind,
    b_stored: storeB.map((s) => ({ node: s.nodeId, enc: s.enc, rec: s.rec })),
    c_stored: storeC.map((s) => ({ node: s.nodeId, enc: s.enc, rec: s.rec })),
    c_derive_enc_calls: deriveEncCalls,
    // Every transport the fan-out builds is flagged rewrap-only, so a stored
    // bundle it cannot open is reported, not silently replaced with a new one.
    all_rewrap_only: rewrapOnlySeen.length > 0 && rewrapOnlySeen.every(Boolean),
  }));
})().catch((e) => { console.error(e); process.exit(1); });
"""


@pytest.fixture(scope="module")
def result(tmp_path_factory):
    d = tmp_path_factory.mktemp("rewrap")
    harness = d / "harness.cjs"
    harness.write_text(_HARNESS)
    proc = subprocess.run(
        ["node", str(harness), str(TRANSPORT)],
        capture_output=True, text=True, timeout=120,
    )
    if proc.returncode != 0:
        pytest.fail(f"node harness failed:\n{proc.stderr[-2000:]}")
    return json.loads(proc.stdout)


def test_a_reachable_node_with_an_identity_is_updated(result):
    assert "a@ann" in result["a_updated"]
    assert result["a_stored_nodes"] == ["n-ok"]


def test_a_group_with_no_online_node_is_unreachable(result):
    assert result["a_unreachable"] == ["b@ann"]


def test_a_nodes_lookup_error_and_a_failed_handshake_land_in_failed(result):
    assert "c@ann" in result["a_failed"]   # /nodes returned 503
    assert "d@ann" in result["a_failed"]   # connect() threw


def test_a_node_that_never_had_our_identity_is_not_written_but_not_a_failure(result):
    # gE: connect minted a fresh identity — nothing is stranded, so the group is
    # "updated", and no keypair_bundle_store is sent for it.
    assert "e@ann" in result["a_updated"]
    assert "n-fresh" not in result["a_stored_nodes"]


def test_a_node_that_returns_no_identity_is_a_failure(result):
    assert "f@ann" in result["a_failed"]


def test_flow_a_writes_only_the_passphrase_copy(result):
    assert result["a_recovery_always_null"] is True
    assert result["a_new_bundle_key_kind"] == "enc"


def test_flow_b_writes_both_the_passphrase_and_the_recovery_copy(result):
    assert result["b_stored"] == [
        {"node": "n-ok", "enc": "wrapped:enc", "rec": "wrapped:rec"},
    ]


def test_profile_backfill_keeps_the_live_key_and_adds_the_recovery_copy(result):
    # bundleKey mode: the passphrase copy is re-wrapped with the same live key
    # (kind "bk"), the recovery copy is added, and no passphrase is derived.
    assert result["c_stored"] == [
        {"node": "n-ok", "enc": "wrapped:bk", "rec": "wrapped:rec"},
    ]
    assert result["c_derive_enc_calls"] == 0


def test_every_fanout_transport_is_rewrap_only(result):
    assert result["all_rewrap_only"] is True