import test from 'node:test'
import assert from 'node:assert/strict'
import { loadModule } from './load.mjs'
import { makeCtx } from './helpers/fakeCtx.mjs'

// Aufzug: Warteschlange, Zustandsautomat, Abbruch/Reset und Kabine (Quelle: entwuerfe/scene-turm.js)
const { createLift, LIFT } = await loadModule('src/components/workers/engine/lift.js')
const { buildLayout, cabTop } = await loadModule('src/components/workers/engine/layout.js')
const { PAL } = await loadModule('src/components/workers/engine/sprites.js')
const { FLOORS } = await loadModule('src/lib/workersRoster.js')

const layout = buildLayout()
function until(lift, fn, max = 12) { let t = 0; while (!fn() && t < max) { lift.update(0.05); t += 0.05 } return t }
// Schritt für Schritt bis zur Bedingung, mit Sicherung gegen Endlosschleifen bei einem Fehler im Aufzug
function stepUntil(step, fn, max = 400) { for (let i = 0; i < max && !fn(); i++) step(); assert.ok(fn(), 'Bedingung nicht erreicht') }
test('Fahrt 1 → 8: queued, open, boarded, arrived, out; Fahrgast folgt der Kabine; danach idle', () => {
  const lift = createLift(layout), a = { x: 0, y: 0, frame: 1 }, req = lift.request(a, 1, 8)
  assert.equal(req.st, 'queued')
  let t = until(lift, () => req.st === 'open'); assert.ok(lift.at(1)); assert.equal(lift.state, 'boarding')
  req.st = 'boarded'; t += until(lift, () => req.st === 'arrived'); assert.ok(lift.at(8)); assert.equal(a.y, cabTop(layout, 8) + 7); assert.equal(a.x, LIFT.cabWx)
  assert.ok(t < 12); req.st = 'out'; lift.update(0.05); assert.equal(lift.state, 'idle')
})
test('FIFO: zweite Anfrage wartet bis die erste ausgestiegen ist', () => {
  const lift = createLift(layout), r1 = lift.request({}, 1, 4), r2 = lift.request({}, 5, 2)
  until(lift, () => r1.st === 'open'); r1.st = 'boarded'; until(lift, () => r1.st === 'arrived'); assert.equal(r2.st, 'queued')
  r1.st = 'out'; until(lift, () => r2.st === 'open'); assert.equal(r2.st, 'open')
})
test('cancel und reset geben die Kabine frei (kein Festhängen)', () => {
  const lift = createLift(layout), a = {}, r1 = lift.request(a, 7, 1), r2 = lift.request({}, 2, 3)
  lift.update(0.05); lift.cancel(a); assert.equal(r1.st, 'cancelled'); until(lift, () => r2.st === 'open'); assert.equal(r2.st, 'open')
  lift.reset(); assert.equal(r2.st, 'cancelled'); assert.equal(lift.state, 'idle')
})

// ---- Ergänzungen: Verhalten, das die drei Tests oben nicht berühren ----

test('LIFT-Werte wie vereinbart und cabH stimmt mit der Kabinenhöhe des Layouts überein', () => {
  assert.deepEqual({ ...LIFT }, { cabWx: 22, exitX: 50, slot0: 52, slotStep: 14, speed: 110, cabH: 21 })
  layout.floors.forEach((f, i) => assert.equal(f.floorY - cabTop(layout, i), LIFT.cabH))
})

test('Start: Kabine steht auf Etage 2 im Leerlauf; at() gilt bis 1,5 Einheiten Abstand und ist bei ungültigem Index false', () => {
  const lift = createLift(layout)
  assert.equal(lift.y, cabTop(layout, 2)); assert.equal(lift.state, 'idle')
  layout.floors.forEach((f, i) => assert.equal(lift.at(i), i === 2, `at(${i})`))
  lift.y = cabTop(layout, 2) + 1.4; assert.ok(lift.at(2))
  lift.y = cabTop(layout, 2) - 1.4; assert.ok(lift.at(2))
  lift.y = cabTop(layout, 2) + 1.5; assert.ok(!lift.at(2))
  for (const i of [-1, 10, 99, 2.5, NaN, '2', undefined, null]) assert.equal(lift.at(i), false)
})

test('Layout mit nur zwei Etagen: Startetage ist die letzte vorhandene (kein Wurf)', () => {
  const small = buildLayout([], FLOORS.slice(0, 2)), lift = createLift(small)
  assert.equal(lift.y, cabTop(small, 1)); assert.ok(lift.at(1))
})

test('Zustandsfolge einer Fahrt; das Schließen dauert 0,3 s', () => {
  const lift = createLift(layout), a = { x: 0, y: 0, frame: 1 }, req = lift.request(a, 4, 6), seen = [lift.state]
  const step = () => { lift.update(0.05); if (seen.at(-1) !== lift.state) seen.push(lift.state) }
  stepUntil(step, () => req.st === 'open')
  assert.equal(lift.state, 'boarding')
  req.st = 'boarded'
  step(); assert.equal(lift.state, 'closing')
  for (let i = 0; i < 5; i++) step()
  assert.equal(lift.state, 'closing') // 0,25 s Tür
  step(); step(); assert.equal(lift.state, 'riding') // 0,35 s
  stepUntil(step, () => req.st === 'arrived')
  assert.equal(lift.state, 'unloading')
  step(); assert.equal(lift.state, 'unloading') // wartet auf den Fahrgast
  req.st = 'out'; step()
  assert.deepEqual(seen, ['idle', 'toPick', 'boarding', 'closing', 'riding', 'unloading', 'idle'])
  assert.equal(req.st, 'out')
})

test('Kabine fährt mit 110 Einheiten pro Sekunde, nach oben und nach unten', () => {
  const lift = createLift(layout), y0 = lift.y
  lift.request({}, 8, 1)
  for (let i = 0; i < 20; i++) lift.update(0.05) // 1 s
  assert.ok(Math.abs(lift.y - (y0 + 110)) < 1e-9, `nach 1 s ${lift.y - y0}`)
  const up = createLift(layout)
  up.request({}, 0, 1)
  for (let i = 0; i < 4; i++) up.update(0.05) // 0,2 s
  assert.ok(Math.abs(up.y - (y0 - 22)) < 1e-9, `nach 0,2 s ${up.y - y0}`)
  for (let i = 0; i < 6; i++) up.update(0.05) // Etage 0 liegt 46 Einheiten höher: erreicht, kein Überschwingen
  assert.equal(up.y, cabTop(layout, 0)); assert.equal(up.state, 'boarding')
})

test('Fahrgast bleibt bis zum Schließen unberührt, folgt dann der Kabine und wird beim Aussteigen losgelassen', () => {
  const lift = createLift(layout), a = { x: 12, y: 34, frame: 1 }, req = lift.request(a, 5, 1)
  until(lift, () => req.st === 'open')
  assert.deepEqual(a, { x: 12, y: 34, frame: 1 }) // Anfahren und Einsteigen: die Regie bewegt ihn
  a.x = LIFT.cabWx; a.y = lift.y + 7; a.frame = 0 // die Regie hat ihn in die Kabine gestellt (Schritt 0, Blick nach vorn)
  req.st = 'boarded'
  let followed = 0
  stepUntil(() => {
    lift.update(0.05)
    if (lift.state === 'closing' || lift.state === 'riding') {
      if (a.y !== lift.y + 7 || a.x !== LIFT.cabWx || a.frame !== 0) assert.fail(`Fahrgast ${a.x}/${a.y}/${a.frame} bei Kabine ${lift.y}`)
      followed++
    }
  }, () => req.st === 'arrived')
  assert.ok(followed > 10, `folgte nur ${followed}-mal`)
  assert.equal(a.y, cabTop(layout, 1) + 7)
  a.x = 77; a.y = 66; a.frame = 1 // Aussteigen: die Regie setzt ihn selbst
  lift.update(0.05); lift.update(0.05)
  assert.deepEqual(a, { x: 77, y: 66, frame: 1 })
})

test('Fahrt auf derselben Etage öffnet sofort und schließt ab', () => {
  const lift = createLift(layout), req = lift.request({}, 2, 2)
  lift.update(0.05); assert.equal(req.st, 'open')
  req.st = 'boarded'; until(lift, () => req.st === 'arrived'); assert.equal(req.st, 'arrived')
  req.st = 'out'; lift.update(0.05); assert.equal(lift.state, 'idle')
})

test('cancel während der Fahrt: Kabine frei, Fahrgast wird nicht mehr bewegt, nächste Anfrage kommt dran', () => {
  const lift = createLift(layout), a = { x: LIFT.cabWx, y: 0, frame: 0 }, r1 = lift.request(a, 2, 9), r2 = lift.request({}, 3, 4)
  until(lift, () => r1.st === 'open'); r1.st = 'boarded'
  until(lift, () => lift.state === 'riding'); lift.update(0.05)
  lift.cancel(a)
  assert.equal(r1.st, 'cancelled'); assert.equal(lift.state, 'idle')
  const before = { ...a }
  lift.update(0.05); assert.deepEqual(a, before)
  until(lift, () => r2.st === 'open'); assert.equal(r2.st, 'open'); assert.equal(lift.state, 'boarding')
  assert.deepEqual(a, before)
})

test('cancel einer wartenden Anfrage: nie bedient, die übrigen bleiben in Reihenfolge; mehrere Anfragen eines Agenten fallen alle', () => {
  const lift = createLift(layout), a2 = {}
  const r1 = lift.request({}, 1, 4), r2 = lift.request(a2, 5, 2), r3 = lift.request({}, 6, 3), r4 = lift.request(a2, 7, 3)
  lift.cancel(a2)
  assert.deepEqual([r1.st, r2.st, r3.st, r4.st], ['queued', 'cancelled', 'queued', 'cancelled'])
  until(lift, () => r1.st === 'open'); r1.st = 'boarded'; until(lift, () => r1.st === 'arrived'); r1.st = 'out'
  const seen = new Set()
  until(lift, () => { seen.add(r2.st).add(r4.st); return r3.st === 'open' })
  assert.equal(r3.st, 'open')
  assert.deepEqual([...seen], ['cancelled'])
})

test('cancel eines unbekannten oder bereits ausgestiegenen Agenten ändert nichts', () => {
  const lift = createLift(layout), a = {}, r = lift.request(a, 2, 3)
  until(lift, () => r.st === 'open'); r.st = 'boarded'; until(lift, () => r.st === 'arrived'); r.st = 'out'
  lift.cancel({}); lift.cancel(undefined); assert.equal(r.st, 'out'); assert.equal(lift.state, 'unloading')
  lift.cancel(a); assert.equal(r.st, 'out') // ausgestiegen bleibt ausgestiegen
  lift.update(0.05); assert.equal(lift.state, 'idle')
})

test('update überspringt von außen abgebrochene Anfragen (wartend und laufend)', () => {
  const lift = createLift(layout)
  const r1 = lift.request({}, 1, 4), r2 = lift.request({}, 5, 2), r3 = lift.request({}, 6, 3)
  r2.st = 'cancelled'
  until(lift, () => r1.st === 'open')
  r1.st = 'cancelled' // laufende Anfrage von außen abgebrochen: kein Festhängen im Zustand boarding
  lift.update(0.05)
  assert.equal(lift.state, 'toPick')
  until(lift, () => r3.st === 'open'); assert.equal(r3.st, 'open')
  assert.equal(r2.st, 'cancelled'); assert.equal(r1.st, 'cancelled')
})

test('reset bricht Wartende und die laufende Anfrage ab, ausgestiegene bleiben; danach fährt der Aufzug wieder', () => {
  const lift = createLift(layout), r1 = lift.request({}, 1, 4), r2 = lift.request({}, 5, 2), r3 = lift.request({}, 6, 3)
  until(lift, () => r1.st === 'open'); r1.st = 'boarded'; until(lift, () => r1.st === 'arrived'); r1.st = 'out'; lift.update(0.05)
  until(lift, () => r2.st === 'open')
  lift.reset()
  assert.deepEqual([r1.st, r2.st, r3.st], ['out', 'cancelled', 'cancelled']); assert.equal(lift.state, 'idle')
  lift.update(0.05); assert.equal(lift.state, 'idle') // Warteschlange ist leer
  const r4 = lift.request({}, 3, 5); until(lift, () => r4.st === 'open'); assert.equal(r4.st, 'open')
})

test('ungültige Anfragen (Etage, Agent) kommen abgebrochen zurück und blockieren nichts', () => {
  const lift = createLift(layout)
  for (const [a, from, to] of [[{}, -1, 3], [{}, 1, 10], [{}, 1.5, 2], [{}, '1', 2], [{}, 1], [{}, NaN, 2], [null, 1, 2], [undefined, 1, 2], ['x', 1, 2]]) {
    const r = lift.request(a, from, to)
    assert.equal(r.st, 'cancelled', JSON.stringify([from, to]))
    assert.equal(r.a, a)
  }
  lift.update(0.05); assert.equal(lift.state, 'idle')
  const ok = lift.request({}, 1, 2); until(lift, () => ok.st === 'open'); assert.equal(ok.st, 'open')
})

test('unbrauchbares dt (0, negativ, NaN, Infinity, kein Zahlentyp) ändert nichts', () => {
  const lift = createLift(layout), r = lift.request({}, 8, 1), y0 = lift.y
  for (const dt of [0, -1, NaN, Infinity, undefined, '0.05']) lift.update(dt)
  assert.equal(lift.state, 'idle'); assert.equal(lift.y, y0); assert.equal(r.st, 'queued')
})

// ---- Kabine zeichnen (Raster 3, kein setGrid: logische Einheit = 3 Geräte-Pixel) ----

const K = 3
const rect = (x, y, w, h, fill) => ({ x: x * K, y: y * K, w: w * K, h: h * K, fill })

test('drawBack: Seil von oben bis zur Kabine, Rückwand mit Handlauf und Fußleiste', () => {
  const lift = createLift(layout), { ctx, rects } = makeCtx(), cy = cabTop(layout, 2)
  lift.drawBack(ctx)
  assert.deepEqual(rects, [
    rect(28, 9, 1, cy - 9, PAL.metal2),
    rect(18, cy, 20, 21, '#f1f3f8'),
    rect(19, cy + 11, 18, 1, '#cfd5df'),
    rect(19, cy + 18, 18, 2, '#e1e5ec'),
  ])
})

test('drawFront: Glasschleier, Rahmen, Lampe und Aufhängung; save/restore gleichen sich aus', () => {
  const lift = createLift(layout), { ctx, rects, counts, alphas } = makeCtx(), cy = cabTop(layout, 2)
  lift.drawFront(ctx)
  assert.deepEqual(rects, [
    rect(19, cy + 1, 18, 19, '#ffffff'),
    rect(18, cy, 20, 1, PAL.metal2),
    rect(18, cy + 20, 20, 1, PAL.metal2),
    rect(18, cy, 1, 21, PAL.metal2),
    rect(37, cy, 1, 21, PAL.metal2),
    rect(24, cy + 1, 8, 1, '#ffe9a8'),
    rect(26, cy - 2, 4, 2, PAL.metal2),
  ])
  assert.deepEqual(alphas, [0.18]); assert.equal(counts.save, 1); assert.equal(counts.restore, 1)
})

test('Kabine wird an der gerundeten Fahrposition gezeichnet und bleibt im Schacht (x 18..38)', () => {
  const lift = createLift(layout)
  lift.request({}, 8, 1)
  lift.update(0.05); lift.update(0.05); lift.update(0.05)
  assert.ok(!Number.isInteger(lift.y), `Testvoraussetzung: Kabine zwischen Rastern (y ${lift.y})`)
  const cy = Math.round(lift.y), back = makeCtx(), front = makeCtx()
  lift.drawBack(back.ctx); lift.drawFront(front.ctx)
  assert.deepEqual(back.rects[1], rect(18, cy, 20, 21, '#f1f3f8'))
  assert.deepEqual(back.rects[0], rect(28, 9, 1, cy - 9, PAL.metal2))
  assert.deepEqual(front.rects[1], rect(18, cy, 20, 1, PAL.metal2))
  for (const r of [...back.rects.slice(1), ...front.rects]) assert.ok(r.x >= 18 * K && r.x + r.w <= 38 * K, JSON.stringify(r))
})