import test from 'node:test'
import assert from 'node:assert/strict'
import { existsSync, readFileSync, statSync } from 'node:fs'
import path from 'node:path'
import { fileURLToPath } from 'node:url'
import esbuild from 'esbuild'
import { loadModule } from './load.mjs'
import { FAKE_REACT } from './helpers/fakeReact.mjs'
import { ev, IDS } from './helpers/workersFixtures.mjs'

// Regie der Hustler-Pixelwelt (T8, Spec E9):
// 1. src/lib/hustlerRegie.js: Ereignisse -> Effekte (Blase, Symbol, Flug, Jubel), Höchstzahl, Rückstau, Zeitablauf mit eigener Uhr, reduziert, flush, kaputte Eingaben.
// 2. RegieEbene.jsx im Mini-Läufer anstelle von React (helpers/fakeReact.mjs, um forwardRef und useImperativeHandle ergänzt), mit eigenem Zeitgeber,
//    eigener Uhr, matchMedia und document.
// 3. hustler-regie.css: Bilder vorhanden, Klassen, Keyframes, „weniger Bewegung“.

const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..')
const R = await loadModule('src/lib/hustlerRegie.js')
const E = await loadModule('src/lib/workersEvents.js')
const W = await loadModule('src/lib/hustlerWelt.js')
const { createRegie, PLAETZE, DAUER, ICON_NACH_FX, kopfPunkt, koerperPunkt } = R
const { EVENT_KINDS } = E
const { HUSTLER } = W

// ---------- Hilfen ----------

// Eigene Uhr: jetzt() liefert den Stand, vor(ms) stellt ihn weiter
function uhrVon(start = 1_000_000) {
  let t = start
  return { jetzt: () => t, vor: (ms) => { t += ms }, stand: () => t }
}

// Alle Effekte, die im Lauf von `bis` Millisekunden einmal sichtbar waren (Schritt 100 ms), in der Reihenfolge ihres Erscheinens
function sammeln(regie, uhr, bis = 8000, schritt = 100) {
  const gesehen = new Map()
  for (let ms = 0; ms <= bis; ms += schritt) {
    for (const e of regie.tick()) if (!gesehen.has(e.id)) gesehen.set(e.id, e)
    uhr.vor(schritt)
  }
  return [...gesehen.values()]
}

// Kurzform eines Effekts für Vergleiche: art[:icon][:wer:text]
const kurz = (e) => (e.art === 'blase' ? `blase:${e.wer}:${e.text}` : e.icon ? `${e.art}:${e.icon}` : e.art)

const ARTEN = new Set(['blase', 'icon', 'flug', 'jubel'])
function pruefeForm(e) {
  assert.ok(ARTEN.has(e.art), `art ${e.art}`)
  assert.equal(typeof e.id, 'string')
  assert.ok(Number.isFinite(e.x) && Number.isFinite(e.y), 'x/y')
  assert.ok(Number.isFinite(e.start) && e.dauer > 0, 'start/dauer')
  assert.equal(e.dauer, DAUER[e.art])
  if (e.art === 'flug') assert.ok(Number.isFinite(e.x2) && Number.isFinite(e.y2), 'x2/y2')
  else assert.ok(!('x2' in e) && !('y2' in e), 'x2/y2 nur beim Flug')
  if (e.art === 'blase') assert.ok(typeof e.text === 'string' && e.text !== '')
  assert.ok(Object.isFrozen(e))
}

// ---------- Plätze und Punkte ----------

test('PLAETZE: vier Plätze in Weltkoordinaten (Briefkasten, Tresor-Tür, Keller, vor dem Eingang links), eingefroren', () => {
  assert.deepEqual(Object.keys(PLAETZE).sort(), ['archiv', 'aussen', 'pult', 'tresor'])
  assert.deepEqual({ ...PLAETZE.pult }, { x: 1240, y: 920 })
  assert.deepEqual({ ...PLAETZE.tresor }, { x: 1375, y: 975 })
  assert.deepEqual({ ...PLAETZE.archiv }, { x: 1250, y: 1040 })
  assert.deepEqual({ ...PLAETZE.aussen }, { x: 900, y: 995 })
  assert.ok(Object.isFrozen(PLAETZE))
  for (const p of Object.values(PLAETZE)) assert.ok(Object.isFrozen(p))
  assert.ok(PLAETZE.aussen.x < W.HAUS_BILD.x, 'aussen liegt links vom Haus')
})

test('Figurpunkte: Kopf = Anker a, f − 36 (Overseer höher), Körper = f − 16; unbekannte Kennungen -> null', () => {
  assert.equal(IDS.length, 19)
  for (const id of IDS) {
    const h = HUSTLER[id]
    assert.ok(h, `${id} fehlt in HUSTLER`)
    assert.deepEqual(kopfPunkt(id), { x: h.a, y: id === 'otto' ? h.f - 44 : h.f - 36 }, id)
    assert.deepEqual(koerperPunkt(id), { x: h.a, y: h.f - 16 }, id)
  }
  assert.ok(kopfPunkt('otto').y < HUSTLER.otto.f - 36, 'Overseer: Blase höher')
  for (const id of ['niemand', '', 'constructor', '__proto__', 'toString', 'pult', 'system', null, undefined, 5, {}]) {
    assert.equal(kopfPunkt(id), null, String(id))
    assert.equal(koerperPunkt(id), null, String(id))
  }
})

// ---------- Zuordnung je Ereignisart ----------

// Ein Ereignis je Art (alle 26 aus EVENT_KINDS) mit den erwarteten Effekten, unabhängig vom Code unter Test aus Übersicht §7 abgeleitet
const TABELLE = {
  auftrag: { w: 'lea', extra: { to: 'max' }, soll: ['blase:lea:Max, los!', 'blase:max:Verstanden'] },
  leerlauf: { w: 'lea', soll: [] },
  gelesen: { w: 'lea', extra: { meta: { count: 3 } }, soll: ['blase:lea:3 gelesen'] },
  fund: { w: 'lea', soll: ['blase:lea:Neuer Fund!', 'icon:akte'] },
  doppelt: { w: 'lea', soll: ['blase:lea:Schon bekannt', 'icon:stopp'] },
  uebergabe: { w: 'lea', extra: { to: 'bea' }, soll: ['flug:umschlag'] },
  bewertet: { w: 'bea', extra: { meta: { score: 82 } }, soll: ['blase:bea:82 Punkte'] },
  top3: { w: 'bea', soll: ['blase:bea:Top 3!', 'icon:haken'] },
  botlead: { w: 'arne', soll: ['blase:arne:Abgelegt', 'icon:akte'] },
  entwurf: { w: 'clara', soll: ['blase:clara:Entwurf fertig'] },
  pult: { w: 'clara', soll: ['blase:clara:Zur Freigabe', 'flug:umschlag'] },
  gesendet: { w: 'max', soll: ['blase:max:Raus damit!', 'flug:umschlag'] },
  eingang: { w: 'nora', soll: ['blase:nora:Antwort!', 'flug:umschlag'] },
  sortiert: { w: 'nora', extra: { meta: { classification: 'ja' } }, soll: ['blase:nora:Ja!', 'icon:haken'] },
  bau_start: { w: 'bob', soll: ['blase:bob:Los geht’s'] },
  bau_fertig: { w: 'bob', soll: ['blase:bob:Fertig!', 'flug:umschlag'] },
  pruefung_zurueck: { w: 'paul', extra: { to: 'bob', meta: { round: 2 } }, soll: ['blase:paul:Runde 2 zurück', 'flug:umschlag', 'icon:stopp'] },
  pruefung_ok: { w: 'paul', soll: ['blase:paul:Passt!', 'icon:haken'] },
  vorschau_link: { w: 'bob', soll: ['blase:bob:Link raus', 'flug:umschlag'] },
  angebot: { w: 'theo', soll: ['blase:theo:Kauf-Link!', 'icon:akte'] },
  deal: { w: 'otto', soll: ['blase:otto:Deal! Super!', 'flug:muenze', 'flug:muenze', 'flug:muenze', 'jubel:stern'] },
  gesperrt: { w: 'system', soll: ['blase:arne:Gesperrt', 'icon:stopp'] },
  budget_warnung: { w: 'otto', soll: ['blase:otto:Budget 80 %', 'icon:alarm'] },
  budget_stopp: { w: 'otto', soll: ['blase:otto:Budget leer', 'icon:alarm'] },
  pause: { w: 'system', soll: [] },
  fehler: { w: 'lea', soll: ['blase:lea:Fehler', 'icon:alarm'] },
}

test('Zuordnung: die Tabelle deckt genau die 26 Ereignisarten ab', () => {
  assert.equal(EVENT_KINDS.length, 26)
  assert.deepEqual(Object.keys(TABELLE).sort(), [...EVENT_KINDS].sort())
})

for (const kind of EVENT_KINDS) {
  test(`Zuordnung: ${kind} läuft ohne Fehler und ergibt genau die erwarteten Effekte (wohlgeformt, Münzen mit Versatz)`, () => {
    const { w, extra, soll } = TABELLE[kind]
    const uhr = uhrVon()
    const r = createRegie({ jetzt: uhr.jetzt, max: 50, rueckstau: 50 })
    r.push([ev(kind, w, extra)])
    const effekte = sammeln(r, uhr)
    effekte.forEach(pruefeForm)
    assert.deepEqual(effekte.map(kurz).sort(), [...soll].sort())
    assert.equal(r.wartende(), 0)
    uhr.vor(10_000)
    assert.deepEqual(r.tick(), [])
    assert.equal(r.naechsteIn(), null)
  })
}

test('task und pose erzeugen nichts: leerlauf und pause bleiben leer, auch direkt nach dem Push', () => {
  const uhr = uhrVon()
  const r = createRegie({ jetzt: uhr.jetzt })
  r.push([ev('leerlauf', 'lea'), ev('pause', 'system')])
  assert.deepEqual(r.tick(), [])
  assert.equal(r.naechsteIn(), null)
})

test('say: Sprechblase 2,5 s an der Spitze über dem Kopf des Workers, Text so lang wie im Schritt (höchstens 20 Zeichen)', () => {
  const uhr = uhrVon(42_000)
  const r = createRegie({ jetzt: uhr.jetzt })
  r.push([ev('gelesen', 'lea', { meta: { count: 3 } })])
  const [b, ...rest] = r.tick()
  assert.equal(rest.length, 0)
  assert.equal(b.art, 'blase'); assert.equal(b.wer, 'lea'); assert.equal(b.text, '3 gelesen')
  assert.deepEqual([b.x, b.y], [HUSTLER.lea.a, HUSTLER.lea.f - 36])
  assert.equal(b.start, 42_000); assert.equal(b.dauer, 2500)
  assert.ok(b.text.length <= 20)
  // Overseer: Blase höher als bei den anderen
  r.push([ev('budget_stopp', 'otto')])
  const otto = r.tick().find((e) => e.art === 'blase' && e.wer === 'otto')
  assert.deepEqual([otto.x, otto.y], [HUSTLER.otto.a, HUSTLER.otto.f - 44])
})

test('fund: Blase „Neuer Fund!“ am Kopf plus Symbol Akte neben der Figur (1,2 s)', () => {
  const uhr = uhrVon()
  const r = createRegie({ jetzt: uhr.jetzt })
  r.push([ev('fund', 'ali')])
  const effekte = r.tick()
  assert.equal(effekte.length, 2)
  const blase = effekte.find((e) => e.art === 'blase')
  const icon = effekte.find((e) => e.art === 'icon')
  assert.equal(blase.text, 'Neuer Fund!'); assert.deepEqual([blase.x, blase.y], [HUSTLER.ali.a, HUSTLER.ali.f - 36])
  assert.equal(icon.icon, 'akte'); assert.equal(icon.dauer, 1200)
  // das Symbol sitzt neben der Figur (rechts), nicht auf der Blase
  assert.ok(icon.x > HUSTLER.ali.a && icon.x < HUSTLER.ali.a + 40)
  assert.ok(icon.y > blase.y && icon.y < HUSTLER.ali.f)
})

test('fx am Ort: Symbole paper/drawer -> akte, stampOk -> haken, stampNo -> stopp, alert -> alarm (ICON_NACH_FX)', () => {
  assert.deepEqual({ ...ICON_NACH_FX }, { paper: 'akte', stampOk: 'haken', stampNo: 'stopp', drawer: 'akte', alert: 'alarm' })
  const uhr = uhrVon()
  const r = createRegie({ jetzt: uhr.jetzt, max: 50, rueckstau: 50 })
  r.push([ev('fund', 'lea'), ev('top3', 'bea'), ev('doppelt', 'sven'), ev('botlead', 'arne'), ev('fehler', 'kim')])
  const icons = r.tick().filter((e) => e.art === 'icon')
  assert.deepEqual(icons.map((e) => e.icon), ['akte', 'haken', 'stopp', 'akte', 'alarm'])
})

test('gesendet: Umschlag fliegt 900 ms von Max nach „aussen“; von system (Mensch am Pult) vom Briefkasten nach „aussen“', () => {
  const uhr = uhrVon()
  const r = createRegie({ jetzt: uhr.jetzt })
  r.push([ev('gesendet', 'max')])
  const flug = r.tick().find((e) => e.art === 'flug')
  assert.equal(flug.icon, 'umschlag'); assert.equal(flug.dauer, 900)
  assert.deepEqual([flug.x, flug.y], [HUSTLER.max.a, HUSTLER.max.f - 16])
  assert.deepEqual([flug.x2, flug.y2], [PLAETZE.aussen.x, PLAETZE.aussen.y])
  r.flush()
  r.push([ev('gesendet', 'system')])
  const alle = r.tick()
  assert.deepEqual(alle.map(kurz), ['flug:umschlag'])
  assert.deepEqual([alle[0].x, alle[0].y, alle[0].x2, alle[0].y2], [PLAETZE.pult.x, PLAETZE.pult.y, PLAETZE.aussen.x, PLAETZE.aussen.y])
})

test('give und fx mit Ziel: Flüge zwischen Figuren, zum Briefkasten und von draußen zum Worker; gleicher Start und Ziel fliegt nicht', () => {
  const uhr = uhrVon()
  const r = createRegie({ jetzt: uhr.jetzt, max: 50, rueckstau: 50 })
  r.push([ev('uebergabe', 'lea', { to: 'bea' }), ev('pult', 'clara'), ev('eingang', 'nora'), ev('uebergabe', 'lea', { to: 'lea' })])
  const fluege = r.tick().filter((e) => e.art === 'flug')
  assert.equal(fluege.length, 3)
  const koerper = (id) => [HUSTLER[id].a, HUSTLER[id].f - 16]
  assert.deepEqual([fluege[0].x, fluege[0].y, fluege[0].x2, fluege[0].y2], [...koerper('lea'), ...koerper('bea')])
  assert.deepEqual([fluege[1].x, fluege[1].y, fluege[1].x2, fluege[1].y2], [...koerper('clara'), PLAETZE.pult.x, PLAETZE.pult.y])
  assert.deepEqual([fluege[2].x, fluege[2].y, fluege[2].x2, fluege[2].y2], [PLAETZE.aussen.x, PLAETZE.aussen.y, ...koerper('nora')])
})

test('deal: drei Münzflüge von „aussen“ zum Tresor mit 0,4 s Versatz, Jubel-Stern und Blase beim Overseer', () => {
  const uhr = uhrVon(10_000)
  const r = createRegie({ jetzt: uhr.jetzt, max: 8 })
  r.push([ev('deal', 'otto')])
  // sofort: erste Münze, Jubel, Blase; die anderen Münzen sind noch nicht dran
  assert.deepEqual(r.tick().map(kurz).sort(), ['blase:otto:Deal! Super!', 'flug:muenze', 'jubel:stern'])
  assert.equal(r.wartende(), 2)
  assert.equal(r.naechsteIn(), 400)
  uhr.vor(399)
  assert.equal(r.tick().filter((e) => e.icon === 'muenze').length, 1)
  uhr.vor(1)
  assert.equal(r.tick().filter((e) => e.icon === 'muenze').length, 2)
  uhr.vor(400)
  const muenzen = r.tick().filter((e) => e.icon === 'muenze')
  assert.equal(muenzen.length, 3)
  assert.deepEqual(muenzen.map((m) => m.start), [10_000, 10_400, 10_800], 'Versatz 400 ms')
  for (const m of muenzen) {
    assert.deepEqual([m.x, m.y, m.x2, m.y2], [PLAETZE.aussen.x, PLAETZE.aussen.y, PLAETZE.tresor.x, PLAETZE.tresor.y])
    assert.equal(m.dauer, 900)
  }
  const jubel = r.tick().find((e) => e.art === 'jubel')
  assert.equal(jubel.wer, 'otto'); assert.equal(jubel.icon, 'stern'); assert.equal(jubel.dauer, 1200)
  assert.ok(Math.abs(jubel.x - HUSTLER.otto.a) <= 40 && jubel.y < HUSTLER.otto.f && jubel.y > HUSTLER.otto.f - 40, 'Stern neben dem Overseer')
})

test('deal mit der Höchstzahl 4: die dritte Münze wartet, bis die erste (900 ms) im Ziel ist', () => {
  const uhr = uhrVon(10_000)
  const r = createRegie({ jetzt: uhr.jetzt })
  r.push([ev('deal', 'otto')])
  r.tick()
  uhr.vor(800)
  assert.equal(r.tick().filter((e) => e.icon === 'muenze').length, 2)
  assert.equal(r.tick().length, 4)
  uhr.vor(100)
  const muenzen = r.tick().filter((e) => e.icon === 'muenze')
  assert.equal(muenzen.length, 2) // erste weg, dritte da
  assert.equal(muenzen[1].start, 10_900)
})

// ---------- Höchstzahl, Rückstau, Zeitablauf ----------

test('Höchstzahl: nie mehr als max zugleich sichtbar (Standard 4), wartende rücken nach, sobald einer abläuft', () => {
  const uhr = uhrVon()
  const r = createRegie({ jetzt: uhr.jetzt })
  r.push(IDS.slice(0, 6).map((id) => ev('fund', id))) // 12 Entwürfe
  let gesehen = 0
  for (let ms = 0; ms <= 20_000; ms += 50) {
    const jetzt = r.tick()
    assert.ok(jetzt.length <= 4, `${jetzt.length} bei ${ms} ms`)
    gesehen = Math.max(gesehen, jetzt.length)
    uhr.vor(50)
  }
  assert.equal(gesehen, 4)
  assert.deepEqual(r.tick(), [])
  assert.equal(r.wartende(), 0)

  // eine andere Höchstzahl
  const r2 = createRegie({ jetzt: uhr.jetzt, max: 2 })
  r2.push(IDS.slice(0, 5).map((id) => ev('fund', id)))
  assert.equal(r2.tick().length, 2)
  // erster Ablauf: Symbole nach 1,2 s, dann rücken die nächsten nach (Start = Zeitpunkt des Ablaufs)
  const anfang = uhr.stand()
  uhr.vor(1200)
  const danach = r2.tick()
  assert.equal(danach.length, 2)
  assert.ok(danach.some((e) => e.start === anfang + 1200))
})

test('Reihenfolge der Wartenden: wer zuerst kam, startet zuerst (max 1)', () => {
  const uhr = uhrVon()
  const r = createRegie({ jetzt: uhr.jetzt, max: 1 })
  r.push(['kim', 'pia', 'finn'].map((id, i) => ev('gelesen', id, { meta: { count: i + 1 } })))
  const texte = []
  for (let i = 0; i < 3; i += 1) {
    texte.push(...r.tick().map((e) => e.text))
    uhr.vor(2500)
  }
  assert.deepEqual(texte, ['1 gelesen', '2 gelesen', '3 gelesen'])
})

test('Rückstau: mehr als 12 Wartende -> die ältesten fallen weg, die neuesten bleiben (19 Blasen: 1-4 laufen, 5-7 fallen weg, 8-19 warten)', () => {
  const uhr = uhrVon()
  const r = createRegie({ jetzt: uhr.jetzt })
  r.push(IDS.map((id, i) => ev('gelesen', id, { meta: { count: i + 1 } })))
  assert.equal(r.tick().length, 4)
  assert.equal(r.wartende(), 12)
  const effekte = sammeln(r, uhr, 20_000, 50)
  const zahlen = effekte.map((e) => Number.parseInt(e.text, 10))
  assert.deepEqual(zahlen, [1, 2, 3, 4, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19])
  assert.equal(r.wartende(), 0)
})

test('Rückstau einstellbar: max 1, rueckstau 3, acht Blasen -> 1 läuft, 2-5 fallen weg, danach 6, 7, 8', () => {
  const uhr = uhrVon()
  const r = createRegie({ jetzt: uhr.jetzt, max: 1, rueckstau: 3 })
  r.push(IDS.slice(0, 8).map((id, i) => ev('gelesen', id, { meta: { count: i + 1 } })))
  assert.equal(r.wartende(), 3)
  const texte = []
  for (let i = 0; i < 6; i += 1) {
    texte.push(...r.tick().map((e) => e.text))
    uhr.vor(2500)
  }
  assert.deepEqual(texte, ['1 gelesen', '6 gelesen', '7 gelesen', '8 gelesen'])
})

test('Rückstau 0: was nicht sofort starten kann, fällt weg', () => {
  const uhr = uhrVon()
  const r = createRegie({ jetzt: uhr.jetzt, max: 1, rueckstau: 0 })
  r.push(IDS.slice(0, 3).map((id, i) => ev('gelesen', id, { meta: { count: i + 1 } })))
  assert.equal(r.wartende(), 0)
  assert.deepEqual(r.tick().map((e) => e.text), ['1 gelesen'])
})

test('Zeitablauf mit eigener Uhr: Blase 2500 ms, Symbol 1200 ms, Flug 900 ms; naechsteIn zählt bis zum nächsten Ablauf', () => {
  const uhr = uhrVon(5000)
  const r = createRegie({ jetzt: uhr.jetzt })
  r.push([ev('fund', 'lea'), ev('gesendet', 'max')])
  assert.equal(r.tick().length, 4) // Blase + Akte (lea), Blase + Flug (max)
  assert.equal(r.naechsteIn(), 900)
  uhr.vor(899)
  assert.equal(r.tick().length, 4)
  assert.equal(r.naechsteIn(), 1)
  uhr.vor(1)
  assert.deepEqual(r.tick().map(kurz).sort(), ['blase:lea:Neuer Fund!', 'blase:max:Raus damit!', 'icon:akte'])
  assert.equal(r.naechsteIn(), 300)
  uhr.vor(300)
  assert.deepEqual(r.tick().map(kurz).sort(), ['blase:lea:Neuer Fund!', 'blase:max:Raus damit!'])
  uhr.vor(1299)
  assert.equal(r.tick().length, 2)
  uhr.vor(1)
  assert.deepEqual(r.tick(), [])
  assert.equal(r.naechsteIn(), null)
})

test('tick: neues Feld je Aufruf, dieselben (eingefrorenen) Effekte, solange sie laufen; start bleibt', () => {
  const uhr = uhrVon()
  const r = createRegie({ jetzt: uhr.jetzt })
  r.push([ev('fund', 'lea')])
  const a = r.tick()
  uhr.vor(500)
  const b = r.tick()
  assert.notEqual(a, b)
  assert.equal(a[0], b[0])
  assert.equal(b[0].start, 1_000_000)
  a.pop()
  assert.equal(r.tick().length, 2, 'das Feld gehört dem Aufrufer')
  assert.equal(new Set(r.tick().map((e) => e.id)).size, 2)
})

test('Standarduhr: ohne jetzt wird Date.now benutzt', () => {
  const r = createRegie()
  const vorher = Date.now()
  r.push([ev('fund', 'lea')])
  const [e] = r.tick()
  assert.ok(e.start >= vorher && e.start <= Date.now())
})

// ---------- Eine Blase je Worker ----------

test('eine Blase je Worker: die neue ersetzt die laufende, auch wenn alle Plätze belegt sind', () => {
  const uhr = uhrVon()
  const r = createRegie({ jetzt: uhr.jetzt, max: 1 })
  r.push([ev('gelesen', 'lea', { meta: { count: 1 } })])
  assert.deepEqual(r.tick().map((e) => e.text), ['1 gelesen'])
  uhr.vor(500)
  r.push([ev('gelesen', 'lea', { meta: { count: 2 } })])
  assert.deepEqual(r.tick().map((e) => e.text), ['2 gelesen'])
  assert.equal(r.wartende(), 0)
  assert.equal(r.tick()[0].start, uhr.stand())
  // andere Worker haben eigene Blasen
  const r2 = createRegie({ jetzt: uhr.jetzt })
  r2.push([ev('gelesen', 'lea', { meta: { count: 1 } }), ev('gelesen', 'sven', { meta: { count: 2 } }), ev('gelesen', 'lea', { meta: { count: 3 } })])
  assert.deepEqual(r2.tick().map((e) => `${e.wer}:${e.text}`).sort(), ['lea:3 gelesen', 'sven:2 gelesen'])
})

test('eine Blase je Worker: eine noch wartende Blase wird von der nächsten desselben Workers ersetzt', () => {
  const uhr = uhrVon()
  const r = createRegie({ jetzt: uhr.jetzt, max: 1 })
  r.push([ev('gelesen', 'kim', { meta: { count: 1 } })]) // läuft
  r.push([ev('gelesen', 'lea', { meta: { count: 2 } })]) // wartet
  r.push([ev('gelesen', 'lea', { meta: { count: 3 } })]) // ersetzt die wartende
  assert.equal(r.wartende(), 1)
  const texte = []
  for (let i = 0; i < 3; i += 1) {
    texte.push(...r.tick().map((e) => e.text))
    uhr.vor(2500)
  }
  assert.deepEqual(texte, ['1 gelesen', '3 gelesen'])
})

test('Blasen ersetzen nur Blasen: Symbole und Flüge desselben Workers laufen weiter', () => {
  const uhr = uhrVon()
  const r = createRegie({ jetzt: uhr.jetzt })
  r.push([ev('fund', 'lea')])
  uhr.vor(300)
  r.push([ev('gelesen', 'lea', { meta: { count: 9 } })])
  assert.deepEqual(r.tick().map(kurz).sort(), ['blase:lea:9 gelesen', 'icon:akte'])
})

// ---------- reduziert, flush ----------

test('reduziert: nur Blasen, alles andere (Symbole, Flüge, Jubel) fällt weg', () => {
  const uhr = uhrVon()
  const r = createRegie({ jetzt: uhr.jetzt, reduziert: true })
  r.push([ev('fund', 'lea'), ev('gesendet', 'max'), ev('deal', 'otto'), ev('top3', 'bea')])
  const effekte = sammeln(r, uhr)
  assert.deepEqual(effekte.map(kurz).sort(), ['blase:bea:Top 3!', 'blase:lea:Neuer Fund!', 'blase:max:Raus damit!', 'blase:otto:Deal! Super!'])
  assert.equal(r.wartende(), 0)
})

test('setReduziert: schaltet zur Laufzeit um, entfernt laufende und wartende Nicht-Blasen sofort; danach wieder alles', () => {
  const uhr = uhrVon()
  const r = createRegie({ jetzt: uhr.jetzt })
  r.push([ev('deal', 'otto')])
  assert.equal(r.tick().length, 3)
  assert.equal(r.wartende(), 2)
  r.setReduziert(true)
  assert.deepEqual(r.tick().map(kurz), ['blase:otto:Deal! Super!'])
  assert.equal(r.wartende(), 0)
  assert.equal(r.naechsteIn(), 2500)
  r.push([ev('fund', 'lea')])
  assert.deepEqual(r.tick().map(kurz).sort(), ['blase:lea:Neuer Fund!', 'blase:otto:Deal! Super!'])
  r.setReduziert(false)
  r.push([ev('top3', 'bea')])
  assert.ok(r.tick().some((e) => e.art === 'icon' && e.icon === 'haken'))
})

test('flush: leert Warteschlange und laufende Effekte; danach geht es normal weiter', () => {
  const uhr = uhrVon()
  const r = createRegie({ jetzt: uhr.jetzt, max: 2 })
  r.push(IDS.slice(0, 6).map((id) => ev('fund', id)))
  assert.equal(r.tick().length, 2)
  assert.ok(r.wartende() > 0)
  r.flush()
  assert.deepEqual(r.tick(), [])
  assert.equal(r.wartende(), 0)
  assert.equal(r.naechsteIn(), null)
  uhr.vor(60_000)
  assert.deepEqual(r.tick(), [])
  r.push([ev('top3', 'bea')])
  assert.equal(r.tick().length, 2)
  // Kennungen bleiben auch nach flush eindeutig
  const ids = r.tick().map((e) => e.id)
  r.flush()
  r.push([ev('top3', 'bea')])
  assert.ok(r.tick().every((e) => !ids.includes(e.id)))
})

test('naechsteIn: null im Leerlauf, Rest der Laufzeit, Beginn der nächsten verzögerten Münze', () => {
  const uhr = uhrVon()
  const r = createRegie({ jetzt: uhr.jetzt })
  assert.equal(r.naechsteIn(), null)
  r.push([ev('gelesen', 'lea')])
  assert.equal(r.naechsteIn(), 2500)
  uhr.vor(1000)
  assert.equal(r.naechsteIn(), 1500)
  uhr.vor(1500)
  assert.equal(r.naechsteIn(), 0) // abgelaufen, aber noch nicht abgeholt
  assert.deepEqual(r.tick(), [])
  assert.equal(r.naechsteIn(), null)
})

// ---------- Unbekannte Worker, kaputte Eingaben ----------

test('unbekannte Worker und Plätze erzeugen nichts', () => {
  const uhr = uhrVon()
  const r = createRegie({ jetzt: uhr.jetzt })
  r.push([
    ev('fund', 'niemand'), ev('gelesen', ''), ev('fund', '__proto__'), ev('fund', 'constructor'), ev('fund', 'toString'),
    ev('uebergabe', 'lea', { to: 'niemand' }), ev('uebergabe', 'niemand', { to: 'lea' }), ev('pult', 'niemand'), ev('eingang', 'niemand'),
    ev('auftrag', 'otto', { to: 'niemand' }),
  ])
  // auftrag an einen Unbekannten bleibt ein reiner task-Schritt: auch Ottos Blase „… los!“ entfällt
  assert.deepEqual(r.tick().map(kurz), [])
  assert.equal(r.wartende(), 0)
})

test('kaputte Eingaben: push mit Nicht-Listen, Nicht-Ereignissen, falschen Feldern und werfenden Getter wirft nie; gute Ereignisse laufen trotzdem', () => {
  const uhr = uhrVon()
  const r = createRegie({ jetzt: uhr.jetzt, max: 50, rueckstau: 50 })
  for (const kaputt of [undefined, null, 5, 'text', {}, new Set([1]), () => {}]) assert.doesNotThrow(() => r.push(kaputt))
  const werfend = { id: 'x', ts: '2026-10-17T20:00:00.000Z', workerId: 'lea', text: 'A', get kind() { throw new Error('kaputt') } }
  assert.doesNotThrow(() => r.push([
    null, undefined, 5, 'fund', [], {}, { kind: 'fund' }, { kind: 'fund', workerId: 5 }, { kind: 7, workerId: 'lea' },
    { kind: 'unbekannt', workerId: 'lea', text: 'T' }, { kind: 'gelesen', workerId: 'lea', meta: '{kaputt' }, { kind: 'gelesen', workerId: 'lea', meta: [] },
    { kind: 'deal', workerId: 'otto', meta: 5, text: {} }, werfend, ev('top3', 'bea'),
  ]))
  const effekte = r.tick()
  effekte.forEach(pruefeForm)
  assert.ok(effekte.some((e) => e.art === 'blase' && e.wer === 'bea' && e.text === 'Top 3!'))
  assert.ok(effekte.some((e) => e.art === 'blase' && e.wer === 'lea' && e.text === 'Gelesen'), 'kaputtes meta zählt wie leer')
  assert.equal(effekte.filter((e) => e.art === 'blase' && e.wer === 'lea').length, 1)
})

test('Blasen mit leerem oder fremdem Text entfallen; Text wird nur gekürzt, nie als HTML gedeutet', () => {
  const uhr = uhrVon()
  const r = createRegie({ jetzt: uhr.jetzt, max: 50 })
  // eventToSteps setzt feste Texte; Ereignis-Texte landen nur in task und erscheinen nie in einer Blase
  r.push([ev('fund', 'lea', { text: '<img src=x onerror=alert(1)>' })])
  const texte = r.tick().filter((e) => e.art === 'blase').map((e) => e.text)
  assert.deepEqual(texte, ['Neuer Fund!'])
})

test('Optionen: ungültige max/rueckstau/jetzt fallen auf die Standardwerte zurück; kaputte Uhr stürzt nicht', () => {
  for (const max of [NaN, 0, -3, 'a', null, Infinity]) {
    const uhr = uhrVon()
    const r = createRegie({ jetzt: uhr.jetzt, max, rueckstau: 'x' })
    r.push(IDS.slice(0, 6).map((id) => ev('fund', id)))
    assert.equal(r.tick().length, 4, `max ${String(max)}`)
    assert.equal(r.wartende(), 8)
  }
  const r2 = createRegie({ jetzt: () => NaN })
  assert.doesNotThrow(() => { r2.push([ev('fund', 'lea')]); r2.tick(); r2.naechsteIn() })
  const r3 = createRegie({})
  assert.doesNotThrow(() => r3.push([ev('fund', 'lea')]))
})

test('Quelltext: rein (kein React, window, document, Zeitgeber); Importe nur workersEvents, hustlerWelt, workersRoster', () => {
  const src = readFileSync(path.join(ROOT, 'src/lib/hustlerRegie.js'), 'utf8')
  const code = src.replace(/\/\/.*$/gm, '')
  assert.doesNotMatch(code, /\b(window|document|setTimeout|setInterval|localStorage)\b/)
  assert.doesNotMatch(code, /from 'react'|from "react"/)
  const importe = [...src.matchAll(/^import .* from '([^']+)'/gm)].map((m) => m[1])
  for (const i of importe) assert.ok(['./workersEvents.js', './hustlerWelt.js', './workersRoster.js'].includes(i), i)
  assert.doesNotMatch(src, /engine\/director/)
})

// ---------- RegieEbene (Mini-Läufer) ----------

// forwardRef und useImperativeHandle liefert der gemeinsame Mini-Läufer (helpers/fakeReact.mjs)
const FAKE_REACT_MIT_REF = FAKE_REACT
const fakeReactMitRef = {
  name: 'fake-react-mit-ref',
  setup(build) {
    build.onResolve({ filter: /^react(\/jsx-runtime)?$/ }, () => ({ path: 'react', namespace: 'fake-react' }))
    build.onLoad({ filter: /.*/, namespace: 'fake-react' }, () => ({ contents: FAKE_REACT_MIT_REF, loader: 'js' }))
  },
}

let ebeneBundle
const ladeEbene = () => (ebeneBundle ??= esbuild.build({
  stdin: { contents: "export { __mount, jsx } from 'react'\nexport { default as RegieEbene } from './src/components/workers/hochhaus/RegieEbene.jsx'", resolveDir: ROOT, loader: 'js' },
  bundle: true, format: 'esm', platform: 'neutral', write: false, jsx: 'automatic', loader: { '.jsx': 'jsx' }, plugins: [fakeReactMitRef],
}).then((out) => import(`data:text/javascript;base64,${Buffer.from(out.outputFiles[0].text).toString('base64')}`)))

// Umgebung mit eigenem Zeitgeber, eigener Uhr (Date.now), matchMedia und document; ende() stellt alles zurück
function umgebung({ bewegung = false, verdeckt = false, ohneFenster = false } = {}) {
  const alt = { setTimeout: globalThis.setTimeout, clearTimeout: globalThis.clearTimeout, setInterval: globalThis.setInterval, now: Date.now, window: globalThis.window, document: globalThis.document }
  let t = 1_000_000
  let nr = 0
  const zeitgeber = new Map()
  const intervalle = []
  globalThis.setTimeout = (fn, ms) => { nr += 1; zeitgeber.set(nr, { fn, bei: t + (ms ?? 0) }); return nr }
  globalThis.clearTimeout = (id) => { zeitgeber.delete(id) }
  globalThis.setInterval = (...args) => { intervalle.push(args); return 0 }
  Date.now = () => t
  const media = {
    matches: bewegung,
    zuhoerer: new Set(),
    addEventListener(art, fn) { if (art === 'change') this.zuhoerer.add(fn) },
    removeEventListener(art, fn) { if (art === 'change') this.zuhoerer.delete(fn) },
    aendern(matches) { this.matches = matches; for (const fn of [...this.zuhoerer]) fn({ matches }) },
  }
  const doc = {
    hidden: verdeckt,
    zuhoerer: new Set(),
    addEventListener(art, fn) { if (art === 'visibilitychange') this.zuhoerer.add(fn) },
    removeEventListener(art, fn) { if (art === 'visibilitychange') this.zuhoerer.delete(fn) },
    sichtwechsel(hidden) { this.hidden = hidden; for (const fn of [...this.zuhoerer]) fn({}) },
  }
  const anfragen = []
  if (ohneFenster) { delete globalThis.window; delete globalThis.document } else {
    globalThis.window = { matchMedia: (q) => { anfragen.push(q); return media } }
    globalThis.document = doc
  }
  return {
    media, doc, anfragen, intervalle,
    jetzt: () => t,
    offene: () => zeitgeber.size,
    // Zeit vorstellen und dabei die fälligen Zeitgeber in ihrer Reihenfolge auslösen (t steht dann auf dem Zeitpunkt des Zeitgebers)
    vor(ms) {
      const ziel = t + ms
      for (;;) {
        const faellig = [...zeitgeber].filter(([, z]) => z.bei <= ziel).sort((a, b) => a[1].bei - b[1].bei)[0]
        if (!faellig) break
        zeitgeber.delete(faellig[0])
        t = Math.max(t, faellig[1].bei)
        faellig[1].fn()
      }
      t = ziel
    },
    ende() {
      globalThis.setTimeout = alt.setTimeout; globalThis.clearTimeout = alt.clearTimeout; globalThis.setInterval = alt.setInterval; Date.now = alt.now
      if (alt.window === undefined) delete globalThis.window; else globalThis.window = alt.window
      if (alt.document === undefined) delete globalThis.document; else globalThis.document = alt.document
    },
  }
}

const nodes = (node, passt, out = []) => {
  if (node === null || typeof node === 'string') return out
  if (passt(node)) out.push(node)
  for (const kind of node.children) nodes(kind, passt, out)
  return out
}
const textVon = (node) => (typeof node === 'string' ? node : node === null ? '' : node.children.map(textVon).join(''))
const hatKlasse = (n, name) => String(n.props.className ?? '').split(' ').includes(name)
const nachKlasse = (baum, name) => nodes(baum, (n) => typeof n.tag === 'string' && hatKlasse(n, name))

// Ebene einhängen; liefert Baum, Handle und Abbau
async function ebene(umg) {
  const { __mount, jsx, RegieEbene } = await ladeEbene()
  const ref = { current: null }
  const gemountet = __mount(jsx(RegieEbene, { ref }))
  return { ref, tree: () => gemountet.tree(), abbau: () => gemountet.unmount(), spaet: () => gemountet.lateUpdates() }
}

test('RegieEbene: leere Ebene mit hk-regie, aria-hidden, Handle { push, flush }, kein Zeitgeber und kein Intervall im Ruhezustand', async () => {
  const umg = umgebung()
  try {
    const v = await ebene(umg)
    const wurzel = v.tree()
    assert.equal(wurzel.tag, 'div'); assert.equal(wurzel.props.className, 'hk-regie'); assert.equal(wurzel.props['aria-hidden'], 'true')
    assert.deepEqual(wurzel.children, [])
    assert.deepEqual(Object.keys(v.ref.current).sort(), ['flush', 'push'])
    assert.equal(umg.offene(), 0)
    assert.equal(umg.intervalle.length, 0)
    assert.deepEqual(umg.anfragen, ['(prefers-reduced-motion: reduce)'])
    assert.equal(umg.media.zuhoerer.size, 1); assert.equal(umg.doc.zuhoerer.size, 1)
    v.abbau()
  } finally { umg.ende() }
})

test('RegieEbene: Blase in Weltkoordinaten (left/top am Kopf, --dauer), Text als Textknoten; nach Ablauf weg und kein Zeitgeber mehr', async () => {
  const umg = umgebung()
  try {
    const v = await ebene(umg)
    v.ref.current.push([ev('gelesen', 'lea', { meta: { count: 3 } })])
    const blasen = nachKlasse(v.tree(), 'hk-regie-blase')
    assert.equal(blasen.length, 1)
    assert.deepEqual({ ...blasen[0].props.style }, { left: `${HUSTLER.lea.a}px`, top: `${HUSTLER.lea.f - 36}px`, '--dauer': '2500ms' })
    const text = nachKlasse(blasen[0], 'hk-regie-blase-text')
    assert.equal(text.length, 1)
    assert.deepEqual(text[0].children, ['3 gelesen'])
    assert.equal(umg.offene(), 1, 'genau ein Zeitgeber bis zum Ablauf')
    umg.vor(2499)
    assert.equal(nachKlasse(v.tree(), 'hk-regie-blase').length, 1)
    umg.vor(1)
    assert.deepEqual(v.tree().children, [])
    assert.equal(umg.offene(), 0)
    assert.equal(umg.intervalle.length, 0)
    v.abbau()
  } finally { umg.ende() }
})

test('RegieEbene: Symbol (Klasse hk-regie-icon + hk-regie-bild-akte) neben der Figur, Blase bleibt länger als das Symbol', async () => {
  const umg = umgebung()
  try {
    const v = await ebene(umg)
    v.ref.current.push([ev('fund', 'lea')])
    const icons = nachKlasse(v.tree(), 'hk-regie-icon')
    assert.equal(icons.length, 1)
    assert.ok(hatKlasse(icons[0], 'hk-regie-bild-akte'))
    assert.equal(icons[0].props.style.left, `${HUSTLER.lea.a + 22}px`)
    assert.equal(icons[0].props.style.top, `${HUSTLER.lea.f - 26}px`)
    assert.equal(icons[0].props.style['--dauer'], '1200ms')
    assert.equal(nachKlasse(v.tree(), 'hk-regie-blase').length, 1)
    umg.vor(1200)
    assert.equal(nachKlasse(v.tree(), 'hk-regie-icon').length, 0)
    assert.equal(nachKlasse(v.tree(), 'hk-regie-blase').length, 1)
    umg.vor(1300)
    assert.deepEqual(v.tree().children, [])
    assert.equal(umg.offene(), 0)
    v.abbau()
  } finally { umg.ende() }
})

test('RegieEbene: Flug mit Start (left/top) und Weg zum Ziel (--dx/--dy); gesendet fliegt von Max nach „aussen“', async () => {
  const umg = umgebung()
  try {
    const v = await ebene(umg)
    v.ref.current.push([ev('gesendet', 'max')])
    const fluege = nachKlasse(v.tree(), 'hk-regie-flug')
    assert.equal(fluege.length, 1)
    assert.ok(hatKlasse(fluege[0], 'hk-regie-bild-umschlag'))
    const sx = HUSTLER.max.a
    const sy = HUSTLER.max.f - 16
    assert.deepEqual({ ...fluege[0].props.style }, { left: `${sx}px`, top: `${sy}px`, '--dauer': '900ms', '--dx': `${PLAETZE.aussen.x - sx}px`, '--dy': `${PLAETZE.aussen.y - sy}px` })
    umg.vor(900)
    assert.equal(nachKlasse(v.tree(), 'hk-regie-flug').length, 0)
    v.abbau()
  } finally { umg.ende() }
})

test('RegieEbene: deal zeigt Münze 1, Jubel und Blase, 400 ms später Münze 2, und Münze 3 sobald ein Platz frei ist (Höchstzahl 4)', async () => {
  const umg = umgebung()
  try {
    const v = await ebene(umg)
    v.ref.current.push([ev('deal', 'otto')])
    const muenzen = () => nachKlasse(v.tree(), 'hk-regie-bild-muenze')
    assert.equal(muenzen().length, 1)
    assert.equal(nachKlasse(v.tree(), 'hk-regie-jubel').length, 1)
    assert.ok(hatKlasse(nachKlasse(v.tree(), 'hk-regie-jubel')[0], 'hk-regie-bild-stern'))
    assert.equal(nachKlasse(v.tree(), 'hk-regie-blase').length, 1)
    umg.vor(400)
    assert.equal(muenzen().length, 2)
    umg.vor(400)
    assert.equal(muenzen().length, 2, 'bei 800 ms sind vier Plätze belegt')
    umg.vor(100)
    assert.equal(muenzen().length, 2, 'erste Münze weg, dritte da')
    umg.vor(400)
    assert.equal(muenzen().length, 1)
    umg.vor(2500)
    assert.deepEqual(v.tree().children, [])
    assert.equal(umg.offene(), 0)
    v.abbau()
  } finally { umg.ende() }
})

test('RegieEbene: Elemente behalten ihre key-Kennung, solange sie laufen (kein Neustart der CSS-Animation durch andere Effekte)', async () => {
  const umg = umgebung()
  try {
    const v = await ebene(umg)
    v.ref.current.push([ev('gelesen', 'lea')])
    const erste = nachKlasse(v.tree(), 'hk-regie-blase')[0]
    umg.vor(300)
    v.ref.current.push([ev('gelesen', 'sven')])
    const blasen = nachKlasse(v.tree(), 'hk-regie-blase')
    assert.equal(blasen.length, 2)
    assert.equal(blasen[0].props.style.left, erste.props.style.left)
    v.abbau()
  } finally { umg.ende() }
})

test('RegieEbene: „weniger Bewegung“ -> nur Blasen; Wechsel über den Änderungs-Listener wirkt sofort (laufende Flüge verschwinden)', async () => {
  const umg = umgebung({ bewegung: true })
  try {
    const v = await ebene(umg)
    v.ref.current.push([ev('deal', 'otto'), ev('fund', 'lea')])
    assert.equal(nachKlasse(v.tree(), 'hk-regie-blase').length, 2)
    for (const k of ['hk-regie-flug', 'hk-regie-icon', 'hk-regie-jubel']) assert.equal(nachKlasse(v.tree(), k).length, 0, k)
    umg.media.aendern(false)
    v.ref.current.push([ev('deal', 'otto')])
    assert.equal(nachKlasse(v.tree(), 'hk-regie-flug').length, 1)
    assert.equal(nachKlasse(v.tree(), 'hk-regie-jubel').length, 1)
    umg.media.aendern(true)
    assert.equal(nachKlasse(v.tree(), 'hk-regie-flug').length, 0)
    assert.equal(nachKlasse(v.tree(), 'hk-regie-jubel').length, 0)
    assert.ok(nachKlasse(v.tree(), 'hk-regie-blase').length >= 1)
    umg.vor(5000)
    assert.deepEqual(v.tree().children, [])
    assert.equal(umg.offene(), 0)
    v.abbau()
  } finally { umg.ende() }
})

test('RegieEbene: verdeckter Tab leert die Ebene und stoppt den Zeitgeber; solange er verdeckt ist, kommt nichts an; danach geht es weiter', async () => {
  const umg = umgebung()
  try {
    const v = await ebene(umg)
    v.ref.current.push([ev('deal', 'otto'), ev('fund', 'lea')])
    assert.ok(v.tree().children.length > 0)
    assert.ok(umg.offene() > 0)
    umg.doc.sichtwechsel(true)
    assert.deepEqual(v.tree().children, [])
    assert.equal(umg.offene(), 0)
    v.ref.current.push([ev('fund', 'bea')])
    assert.deepEqual(v.tree().children, [], 'verdeckt: nichts sammelt sich an')
    assert.equal(umg.offene(), 0)
    umg.doc.sichtwechsel(false)
    assert.deepEqual(v.tree().children, [])
    v.ref.current.push([ev('fund', 'bea')])
    assert.equal(nachKlasse(v.tree(), 'hk-regie-blase').length, 1)
    v.abbau()
  } finally { umg.ende() }
})

test('RegieEbene: flush über das Handle leert alles und räumt den Zeitgeber auf', async () => {
  const umg = umgebung()
  try {
    const v = await ebene(umg)
    v.ref.current.push([ev('deal', 'otto'), ev('fund', 'lea')])
    assert.ok(umg.offene() > 0)
    v.ref.current.flush()
    assert.deepEqual(v.tree().children, [])
    assert.equal(umg.offene(), 0)
    v.ref.current.push([ev('fund', 'lea')])
    assert.equal(nachKlasse(v.tree(), 'hk-regie-blase').length, 1)
    v.abbau()
  } finally { umg.ende() }
})

test('RegieEbene: Abbau räumt Zeitgeber und Beobachter auf, nimmt das Handle zurück; späte Aufrufe und Zeitgeber ändern nichts', async () => {
  const umg = umgebung()
  try {
    const v = await ebene(umg)
    const handle = v.ref.current
    handle.push([ev('deal', 'otto'), ev('fund', 'lea')])
    assert.ok(umg.offene() > 0)
    v.abbau()
    assert.equal(umg.offene(), 0)
    assert.equal(umg.media.zuhoerer.size, 0)
    assert.equal(umg.doc.zuhoerer.size, 0)
    assert.equal(v.ref.current, null)
    handle.push([ev('fund', 'lea')])
    handle.flush()
    assert.equal(umg.offene(), 0, 'nach dem Abbau startet kein neuer Zeitgeber')
    assert.equal(v.spaet(), 0, 'keine Zustandsänderung nach dem Abbau')
    assert.equal(umg.intervalle.length, 0)
  } finally { umg.ende() }
})

test('RegieEbene: ohne window und document (z. B. Vorschau) läuft sie trotzdem', async () => {
  const umg = umgebung({ ohneFenster: true })
  try {
    const v = await ebene(umg)
    v.ref.current.push([ev('fund', 'lea')])
    assert.equal(nachKlasse(v.tree(), 'hk-regie-icon').length, 1)
    umg.vor(5000)
    assert.deepEqual(v.tree().children, [])
    v.abbau()
    assert.equal(umg.offene(), 0)
  } finally { umg.ende() }
})

test('RegieEbene: kaputte Eingaben über das Handle werfen nicht', async () => {
  const umg = umgebung()
  try {
    const v = await ebene(umg)
    for (const kaputt of [undefined, null, 'x', {}, [null, 5, { kind: 'fund' }]]) assert.doesNotThrow(() => v.ref.current.push(kaputt))
    assert.deepEqual(v.tree().children, [])
    assert.equal(umg.offene(), 0)
    v.abbau()
  } finally { umg.ende() }
})

test('RegieEbene: Quelltext ohne dangerouslySetInnerHTML/innerHTML und ohne Dauer-Intervall, Klassen alle mit hk-regie', () => {
  const src = readFileSync(path.join(ROOT, 'src/components/workers/hochhaus/RegieEbene.jsx'), 'utf8')
  assert.doesNotMatch(src, /dangerouslySetInnerHTML|innerHTML|setInterval/)
  assert.doesNotMatch(src, /^import .*\.(css|png)'/m)
  for (const m of src.matchAll(/className=(?:"([^"]+)"|\{`([^`]+)`\})/g)) {
    for (const klasse of (m[1] ?? m[2]).split(/\s+/)) assert.match(klasse, /^hk-regie/, klasse)
  }
  assert.doesNotMatch(src, /engine\/director/)
})

// ---------- hustler-regie.css ----------

const cssText = readFileSync(path.join(ROOT, 'src/styles/hustler/hustler-regie.css'), 'utf8')
const cssOhneKommentare = cssText.replace(/\/\*[\s\S]*?\*\//g, ' ')

// -> { regeln: [{ selektor, koerper, kontext }], keyframes: [name] }
function zerlege(text) {
  const regeln = []
  const keyframes = []
  let i = 0
  function liste(kontext) {
    for (;;) {
      while (i < text.length && /\s/.test(text[i])) i += 1
      if (i >= text.length) return
      if (text[i] === '}') { i += 1; return }
      const start = i
      while (i < text.length && text[i] !== '{' && text[i] !== '}') i += 1
      const kopf = text.slice(start, i).trim()
      assert.equal(text[i], '{', `Regel ohne Block: ${kopf.slice(0, 60)}`)
      i += 1
      if (kopf.startsWith('@keyframes')) {
        keyframes.push(kopf.slice('@keyframes'.length).trim())
        let tiefe = 1
        while (i < text.length && tiefe > 0) { if (text[i] === '{') tiefe += 1; if (text[i] === '}') tiefe -= 1; i += 1 }
      } else if (kopf.startsWith('@media')) {
        liste(kopf)
      } else {
        const ks = i
        while (i < text.length && text[i] !== '}') i += 1
        regeln.push({ selektor: kopf, koerper: text.slice(ks, i), kontext })
        i += 1
      }
    }
  }
  liste('')
  return { regeln, keyframes }
}
const css = zerlege(cssOhneKommentare)

test('CSS: Kopfkommentar nennt Aufgabe und Namensräume; mehr als zehn Regeln gelesen', () => {
  assert.match(cssText.split('\n')[0], /^\/\* Regie der Hochhaus-Welt/)
  assert.ok(css.regeln.length > 10, `nur ${css.regeln.length} Regeln`)
})

test('CSS: jede Bilddatei aus url(...) existiert unter src/assets/hustler (relativer Pfad, PNG), und die gewünschten Icons sind alle da', () => {
  const urls = [...cssOhneKommentare.matchAll(/url\(\s*([^)]*?)\s*\)/g)].map((m) => m[1].replace(/^["']|["']$/g, ''))
  assert.equal(urls.length, 7)
  const assets = path.join(ROOT, 'src/assets/hustler')
  for (const u of urls) {
    assert.match(u, /^\.\.\/\.\.\/assets\/hustler\/[\w./-]+\.png$/, u)
    const ziel = path.resolve(path.join(ROOT, 'src/styles/hustler'), u)
    assert.ok(ziel.startsWith(assets + path.sep), `${u} liegt außerhalb`)
    assert.ok(existsSync(ziel) && statSync(ziel).isFile(), `${u} fehlt`)
  }
  assert.deepEqual([...urls].map((u) => u.replace('../../assets/hustler/', '')).sort(), [
    'keller/ui/akte-icon.png', 'keller/ui/haken.png', 'keller/ui/stopp.png', 'pult/ui/art-beschwerde.png', 'pult/ui/art-mail.png', 'ui/muenze-gruen.png', 'ui/stern.png',
  ])
})

test('CSS: jede Klasse in einem Selektor heißt hk-regie…, jede Regel steht unter .hk-hochhaus (auch im Media-Block)', () => {
  for (const r of css.regeln) {
    for (const teil of r.selektor.split(',').map((s) => s.trim())) {
      assert.ok(teil.startsWith('.hk-hochhaus '), `nicht unter .hk-hochhaus: ${teil}`)
      const klassen = [...teil.matchAll(/\.(-?[A-Za-z_][\w-]*)/g)].map((m) => m[1]).slice(1)
      assert.ok(klassen.length >= 1, `keine Klasse: ${teil}`)
      for (const k of klassen) assert.match(k, /^hk-regie(-|$)/, `${teil}: ${k}`)
    }
  }
  for (const name of css.keyframes) assert.match(name, /^hk-regie-/, name)
})

test('CSS: alle von der Ebene gesetzten Klassen sind definiert, auch jedes Bild je Symbolname (Regie-Namen)', () => {
  const definiert = new Set(css.regeln.flatMap((r) => [...r.selektor.matchAll(/\.(hk-regie[\w-]*)/g)].map((m) => m[1])))
  const src = readFileSync(path.join(ROOT, 'src/components/workers/hochhaus/RegieEbene.jsx'), 'utf8')
  for (const m of src.matchAll(/hk-regie[\w-]*/g)) {
    if (m[0] === 'hk-regie-bild-') continue // dynamisch: je Symbolname
    assert.ok(definiert.has(m[0]), `${m[0]} fehlt in hustler-regie.css`)
  }
  const symbole = new Set([...Object.values(ICON_NACH_FX), 'umschlag', 'muenze', 'stern'])
  assert.deepEqual([...symbole].sort(), ['akte', 'alarm', 'haken', 'muenze', 'stern', 'stopp', 'umschlag'])
  for (const s of symbole) assert.ok(definiert.has(`hk-regie-bild-${s}`), `hk-regie-bild-${s}`)
})

test('CSS: Keyframes sind definiert und werden benutzt; Dauer kommt aus --dauer', () => {
  const benutzt = new Set([...cssOhneKommentare.matchAll(/animation:\s*(hk-regie-[\w-]+)/g)].map((m) => m[1]))
  assert.deepEqual([...benutzt].sort(), [...css.keyframes].sort())
  for (const name of benutzt) assert.ok(css.keyframes.includes(name), name)
  for (const m of cssOhneKommentare.matchAll(/animation:\s*hk-regie-[\w-]+\s+var\(--dauer, (\d+)ms\)/g)) assert.ok(Number(m[1]) > 0)
  // Standarddauer in der CSS = Dauer der Regie
  assert.match(cssOhneKommentare, new RegExp(`hk-regie-blase var\\(--dauer, ${DAUER.blase}ms\\)`))
  assert.match(cssOhneKommentare, new RegExp(`hk-regie-pop var\\(--dauer, ${DAUER.icon}ms\\)`))
  assert.match(cssOhneKommentare, new RegExp(`hk-regie-flug var\\(--dauer, ${DAUER.flug}ms\\)`))
  assert.match(cssOhneKommentare, new RegExp(`hk-regie-jubel var\\(--dauer, ${DAUER.jubel}ms\\)`))
})

test('CSS: Ebene nimmt keine Klicks an, Pixel-Darstellung, Symbole 16 px (Sprite-Blätter: nur das erste Bild), „weniger Bewegung“ ohne Animation', () => {
  const regel = (teil) => css.regeln.filter((r) => r.selektor.split(',').map((s) => s.trim()).includes(teil))
  const ebeneRegeln = regel('.hk-hochhaus .hk-regie')
  assert.equal(ebeneRegeln.length, 1)
  assert.match(ebeneRegeln[0].koerper, /pointer-events:\s*none/)
  assert.match(ebeneRegeln[0].koerper, /image-rendering:\s*pixelated/)
  assert.ok(regel('.hk-hochhaus .hk-regie *').some((r) => /pointer-events:\s*none/.test(r.koerper)))
  const bild = regel('.hk-hochhaus .hk-regie-icon')[0]
  assert.match(bild.koerper, /width:\s*16px/); assert.match(bild.koerper, /height:\s*16px/)
  assert.match(bild.koerper, /image-rendering:\s*pixelated/)
  assert.match(bild.koerper, /background-position:\s*0 0/) // erstes Bild
  assert.match(bild.koerper, /background-size:\s*auto 16px/) // Sprite-Blatt in Originalgröße, nur Zelle 1 sichtbar
  // Blase: Pixelify Sans, dunkler Rand, Dreieck
  const text = regel('.hk-hochhaus .hk-regie-blase-text')[0].koerper
  assert.match(text, /Pixelify Sans/); assert.match(text, /box-shadow/)
  assert.ok(regel('.hk-hochhaus .hk-regie-blase-text::after').length === 1)
  // weniger Bewegung
  const media = css.regeln.filter((r) => r.kontext.includes('prefers-reduced-motion: reduce'))
  assert.ok(media.length >= 1)
  const ohne = media.flatMap((r) => r.selektor.split(',').map((s) => s.trim()))
  for (const k of ['blase-text', 'icon', 'flug', 'jubel']) assert.ok(ohne.includes(`.hk-hochhaus .hk-regie-${k}`), k)
  for (const r of media) assert.match(r.koerper, /animation:\s*none/)
})

test('CSS: Symbole auf die Größen der Welt begrenzt (12–16 px), keine @import/@font-face/googleapis', () => {
  for (const r of css.regeln) {
    for (const m of r.koerper.matchAll(/(?<![\w-])(?:width|height):\s*(\d+)px/g)) assert.ok(Number(m[1]) <= 16, `${r.selektor}: ${m[0]}`)
  }
  assert.doesNotMatch(cssOhneKommentare, /@import|@font-face|googleapis|\/_blob\//)
})