import { test } from 'node:test';
import assert from 'node:assert/strict';

import { Rng } from '../src/engine/rng.js';
import { genDungeon, pathAt, roomAt, zoneAt, odometer, entityPose, CELL } from '../src/venues/dungeon/map.js';
import { PROP_BUILDERS } from '../src/venues/dungeon/props.js';
import { HAZARD_BUILDERS, avoidanceOffset } from '../src/venues/dungeon/hazards.js';
import { generateVenue } from '../src/venues/VenueGenerator.js';
import { generatePersonality } from '../src/look/Personality.js';

test('dungeon map is deterministic with rooms, zones and a closed route', () => {
    const a = genDungeon({ seed: 7, rng: new Rng(7) });
    const b = genDungeon({ seed: 7, rng: new Rng(7) });
    assert.deepEqual(a, b, 'same seed must generate the same dungeon');
    assert.ok(a.rooms.length >= 3, `only ${a.rooms.length} rooms`);
    const zones = new Set(a.rooms.map((r) => r.zone));
    assert.ok(zones.size >= 3, `zone coverage thin: ${[...zones].join(',')}`);
    assert.ok(a.route.totalLen > 80, `route too short: ${a.route.totalLen}`);
    // pathAt wraps and is pure.
    const s1 = pathAt(a, 3.7), s2 = pathAt(a, 3.7 + a.route.totalLen);
    assert.deepEqual(s1, s2, 'pathAt must wrap seamlessly');
    assert.ok(Number.isFinite(s1.yaw), 'heading must be finite');
});

test('every room is reachable: BFS over open cells hits all rooms', () => {
    for (const seed of [5, 7, 4242]) {
        const m = genDungeon({ seed, rng: new Rng(seed) });
        const seen = new Set([0]);
        const r0 = m.rooms[0];
        const qx = [r0.x + Math.floor(r0.w / 2)], qy = [r0.y + Math.floor(r0.h / 2)];
        const seenCells = new Set([qy[0] * m.w + qx[0]]);
        const roomOf = new Int16Array(m.w * m.h).fill(-1);
        for (const rm of m.rooms) {
            for (let y = rm.y; y < rm.y + rm.h; y++) {
                for (let x = rm.x; x < rm.x + rm.w; x++) roomOf[y * m.w + x] = rm.id;
            }
        }
        let head = 0;
        while (head < qx.length) {
            const cx = qx[head], cy = qy[head];
            head++;
            if (roomOf[cy * m.w + cx] >= 0) seen.add(roomOf[cy * m.w + cx]);
            for (const [dx, dy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) {
                const nx = cx + dx, ny = cy + dy;
                if (nx < 0 || ny < 0 || nx >= m.w || ny >= m.h) continue;
                if (!m.grid[ny * m.w + nx] || seenCells.has(ny * m.w + nx)) continue;
                seenCells.add(ny * m.w + nx);
                qx.push(nx); qy.push(ny);
            }
        }
        assert.equal(seen.size, m.rooms.length,
            `seed ${seed}: reachable ${seen.size}/${m.rooms.length} rooms`);
    }
});

test('the route only walks open cells and visits every room', () => {
    const m = genDungeon({ seed: 7, rng: new Rng(7) });
    // Route samples sit on open cells (checked at cell granularity).
    for (let s = 0; s < m.route.totalLen; s += 2) {
        const p = pathAt(m, s);
        const cx = Math.floor(p.x / CELL + m.w / 2);
        const cy = Math.floor(p.z / CELL + m.h / 2);
        assert.ok(cx >= 0 && cy >= 0 && cx < m.w && cy < m.h, `route off the grid at s=${s}`);
        assert.ok(m.grid[cy * m.w + cx], `route crosses a solid cell at s=${s.toFixed(1)}`);
    }
    const visited = new Set(m.route.roomIds.filter((id) => id >= 0));
    assert.equal(visited.size, m.rooms.length, 'the tour must enter every room');
});

test('no holes indoors, green edges outdoors: every open edge is walled or planted', () => {
    const m = genDungeon({ seed: 7, rng: new Rng(7) });
    const hRuns = m.wallRuns.filter((r) => r.z0 === r.z1);
    const vRuns = m.wallRuns.filter((r) => r.x0 === r.x1);
    const coveredH = (x, z) => hRuns.some((r) =>
        Math.abs(r.z0 - z) < 1e-6 && x + 1e-6 >= r.x0 && x - 1e-6 <= r.x1);
    const coveredV = (x, z) => vRuns.some((r) =>
        Math.abs(r.x0 - x) < 1e-6 && z + 1e-6 >= r.z0 && z - 1e-6 <= r.z1);
    const plantedNear = (x, z) => m.items.vegetation.some((v) =>
        Math.hypot(v.x - x, v.z - z) < 1.6);
    const w0 = (cx) => (cx - m.w / 2) * CELL; // west edge of cell cx
    const z0 = (cy) => (cy - m.h / 2) * CELL;
    // Indoor-ness is the map's own flag (rooms by rect, corridors by the
    // rooms they join) — the test reads it, never re-derives it, so a
    // corridor the tour never walks still judges correctly.
    const cellIndoor = (x, y) => m.indoor[y * m.w + x] === 1;
    let walled = 0, planted = 0;
    for (let y = 0; y < m.h; y++) {
        for (let x = 0; x < m.w; x++) {
            if (!m.grid[y * m.w + x]) continue;
            const openN = (nx, ny) => nx >= 0 && ny >= 0 && nx < m.w && ny < m.h && m.grid[ny * m.w + nx];
            const edges = [];
            if (!openN(x - 1, y)) edges.push(['v', w0(x), z0(y) + CELL / 2]);
            if (!openN(x + 1, y)) edges.push(['v', w0(x) + CELL, z0(y) + CELL / 2]);
            if (!openN(x, y - 1)) edges.push(['h', w0(x) + CELL / 2, z0(y)]);
            if (!openN(x, y + 1)) edges.push(['h', w0(x) + CELL / 2, z0(y) + CELL]);
            for (const [kind, ex, ez] of edges) {
                const covered = kind === 'h' ? coveredH(ex, ez) : coveredV(ex, ez);
                if (cellIndoor(x, y)) {
                    assert.ok(covered, `hole on ${kind === 'h' ? 'horizontal' : 'vertical'} edge of (${x},${y})`);
                    walled++;
                } else {
                    assert.ok(plantedNear(ex, ez) || covered,
                        `outdoor edge of (${x},${y}) neither walled nor planted`);
                    planted++;
                }
            }
        }
    }
    assert.ok(walled > 100, `only ${walled} wall edges checked — map too open?`);
    assert.ok(planted > 20, `only ${planted} planted edges — outdoor bare?`);
    for (const v of m.items.vegetation) {
        assert.ok(['tree', 'bush', 'boulder'].includes(v.kind), `unknown planting ${v.kind}`);
        const cx = Math.floor(v.x / CELL + m.w / 2);
        const cy = Math.floor(v.z / CELL + m.h / 2);
        assert.ok(cx >= 0 && cy >= 0 && cx < m.w && cy < m.h, 'planting off the grid');
        assert.ok(!m.grid[cy * m.w + cx], 'planting on an open cell — it would block the walk');
    }
});

test('watch cells stand on open ground with line-of-sight to the route', () => {
    const m = genDungeon({ seed: 7, rng: new Rng(7) });
    assert.ok(Object.keys(m.watch).length >= m.rooms.length - 1,
        'nearly every room needs a camera chair');
    for (const [id, w] of Object.entries(m.watch)) {
        const cx = Math.floor(w.x / CELL + m.w / 2);
        const cy = Math.floor(w.z / CELL + m.h / 2);
        assert.ok(m.grid[cy * m.w + cx], `watch cell of room ${id} is solid`);
        const rm = m.rooms.find((r) => r.id === Number(id));
        assert.ok(cx >= rm.x && cx < rm.x + rm.w && cy >= rm.y && cy < rm.y + rm.h,
            `watch cell of room ${id} is outside its room`);
    }
});

test('portal sits off-route in a room, facing the walk', () => {
    const m = genDungeon({ seed: 7, rng: new Rng(7) });
    assert.ok(m.portal, 'no portal planned');
    const cx = Math.floor(m.portal.x / CELL + m.w / 2);
    const cy = Math.floor(m.portal.z / CELL + m.h / 2);
    assert.ok(m.grid[cy * m.w + cx], 'portal cell is solid');
    const rm = m.rooms.find((r) => r.id === m.portal.roomId);
    assert.ok(rm && rm.indoor, 'portal belongs in an indoor room');
    assert.ok(Number.isFinite(m.portal.yaw), 'portal yaw must be finite');
});

test('items sit on open cells, off the walked line', () => {
    const m = genDungeon({ seed: 7, rng: new Rng(7) });
    const onOpen = (x, z, what) => {
        const cx = Math.floor(x / CELL + m.w / 2);
        const cy = Math.floor(z / CELL + m.h / 2);
        assert.ok(cx >= 0 && cy >= 0 && cx < m.w && cy < m.h, `${what} off the grid`);
        assert.ok(m.grid[cy * m.w + cx], `${what} on a solid cell`);
    };
    for (const p of m.items.props) {
        assert.ok(PROP_BUILDERS[p.type], `unknown prop ${p.type}`);
        onOpen(p.x, p.z, `prop ${p.type}`);
    }
    assert.ok(m.items.torches.length >= 2, `only ${m.items.torches.length} torches`);
    assert.ok(m.items.torches.length <= 18, 'torch cap blown — clutter');
    for (const tc of m.items.torches) {
        // Sconces hang on indoor stone: an indoor open cell within a step,
        // with a solid neighbour in reach of the bracket — never floating,
        // never buried deep.
        const cx = Math.floor(tc.x / CELL + m.w / 2);
        const cy = Math.floor(tc.z / CELL + m.h / 2);
        let indoorNear = false, solidNear = false, openNear = false;
        for (let dy = -1; dy <= 1; dy++) {
            for (let dx = -1; dx <= 1; dx++) {
                const nx = cx + dx, ny = cy + dy;
                if (nx < 0 || ny < 0 || nx >= m.w || ny >= m.h) continue;
                if (m.grid[ny * m.w + nx]) {
                    openNear = true;
                    if (m.indoor[ny * m.w + nx]) indoorNear = true;
                } else solidNear = true;
            }
        }
        assert.ok(openNear, 'torch buried in stone');
        assert.ok(indoorNear, 'torch burning outdoors');
        assert.ok(solidNear, 'torch with no wall in reach — floating');
    }
    assert.ok(m.items.patrols.length >= 1, 'no patrol lanterns for the open ground');
    assert.ok(m.items.windows.length >= 4, `only ${m.items.windows.length} windows`);
    assert.ok(m.items.puddles.length === 4, 'want exactly 4 puddles');
    for (const g of [...m.items.gates, ...m.items.gaps, ...m.items.patrols]) {
        onOpen(g.x, g.z, 'hazard');
    }
    for (const g of m.items.gates) {
        assert.ok(HAZARD_BUILDERS.gate, 'gate builder missing');
        assert.ok(typeof g.s === 'number', 'gate needs route arclength for the lift');
    }
    // Avoidance stays bounded on the real gate list.
    for (let i = 0; i < 50; i++) {
        const off = avoidanceOffset(i * 1.7, m.items.gates, i * 0.63);
        assert.ok(Number.isFinite(off) && Math.abs(off) <= 1.0, `avoidance out of bounds: ${off}`);
    }
});

test('portcullis stays up for the whole procession, not just the hero', async () => {
    const T = await import('three');
    const { updateHazards, HAZARD_BUILDERS } = await import('../src/venues/dungeon/hazards.js');
    const gate = HAZARD_BUILDERS.gate(T, new Rng(3), [0.45, 0.45, 0.48]);
    gate.userData.home = { x: 0, z: 0, yaw: 0 };
    gate.userData.hazardS = 100;
    const liftOf = (partyS) => {
        updateHazards({ hazards: { items: [gate] }, t: 10, heroS: partyS[0], partyS });
        return gate.userData.liftBars.position.y;
    };
    // Hero under the gate: fully raised.
    assert.ok(liftOf([100]) > 2.3, 'gate not raised for the hero');
    // Hero through, one trailer still under it: must stay fully raised.
    assert.ok(liftOf([104, 100.5, 108]) > 2.3, 'gate dropped on the trailer');
    // Whole party clear: back down.
    assert.ok(liftOf([112, 116, 120]) < 0.1, 'gate stays up with nobody near');
    // Hero-only fallback still behaves (no partyS passed).
    updateHazards({ hazards: { items: [gate] }, t: 10, heroS: 100 });
    assert.ok(gate.userData.liftBars.position.y > 2.3, 'hero-only lift broken');
});

test('roomAt/zoneAt follow the route through rooms and corridors', () => {
    const m = genDungeon({ seed: 7, rng: new Rng(7) });
    const seenRooms = new Set(), seenZones = new Set();
    let corridor = false;
    for (let s = 0; s < m.route.totalLen; s += 1) {
        const r = roomAt(m, s);
        const z = zoneAt(m, s);
        assert.ok(Number.isInteger(r) && r >= -1 && r < m.rooms.length, `bad room ${r}`);
        assert.ok(typeof z === 'string' && z.length > 0, `bad zone ${z}`);
        if (r >= 0) seenRooms.add(r);
        else corridor = true;
        seenZones.add(z);
    }
    assert.equal(seenRooms.size, m.rooms.length, 'route samples must cover every room');
    assert.ok(corridor, 'route never leaves rooms — corridors unused?');
    assert.ok(seenZones.size >= 2, 'route crosses a single zone only');
});

test('the cast assembles: enemies, critters and a wisp on open cells', () => {
    const m = genDungeon({ seed: 7, rng: new Rng(7) });
    const kinds = m.items.entities.map((e) => e.kind);
    assert.ok(kinds.filter((k) => k === 'lurker').length >= 2, `lurkers: ${kinds.join(',')}`);
    assert.ok(kinds.includes('critter'), 'no critters');
    assert.ok(kinds.includes('wisp'), 'no wisp');
    assert.equal(m.items.entities.length, 6, `cast size ${m.items.entities.length}`);
    for (const e of m.items.entities) {
        assert.ok(['lurker', 'sentry', 'critter', 'wisp'].includes(e.kind), `unknown entity ${e.kind}`);
        const cx = Math.floor(e.x / CELL + m.w / 2);
        const cy = Math.floor(e.z / CELL + m.h / 2);
        assert.ok(m.grid[cy * m.w + cx] === 1, `${e.kind} on a solid cell`);
        assert.ok(Number.isFinite(e.s) && Number.isFinite(e.yaw), `${e.kind} missing s/yaw`);
        assert.ok(e.range >= 0 && Number.isFinite(e.speed) && Number.isFinite(e.phase),
            `${e.kind} missing gait params`);
    }
});

test('loot sits a step off the walk, each cache earning its halt', () => {
    const m = genDungeon({ seed: 7, rng: new Rng(7) });
    assert.ok(m.items.loot.length >= 2, `only ${m.items.loot.length} loot spots`);
    assert.ok(m.items.loot.length <= 3, 'loot glut');
    for (const l of m.items.loot) {
        assert.ok(['cache', 'relic', 'hoard'].includes(l.kind), `unknown loot ${l.kind}`);
        const cx = Math.floor(l.x / CELL + m.w / 2);
        const cy = Math.floor(l.z / CELL + m.h / 2);
        assert.ok(m.grid[cy * m.w + cx] === 1, `loot ${l.kind} on a solid cell`);
    }
    assert.equal(m.items.halts.length, m.items.loot.length, 'every cache earns a halt');
    for (let i = 0; i < m.items.halts.length; i++) {
        const h = m.items.halts[i];
        assert.ok(h.dur > 0 && h.dur <= 3, `halt dur ${h.dur}`);
        assert.equal(h.s, m.items.loot[i].s, 'halt must sit on its loot');
        for (let j = i + 1; j < m.items.halts.length; j++) {
            const L = m.route.totalLen;
            const d = Math.abs(h.s - m.items.halts[j].s) % L;
            assert.ok(Math.min(d, L - d) >= 15, 'halts overlap — the odometer could retreat');
        }
    }
});

test('odometer holds at halts and never retreats', () => {
    const cruise = 1.4, L = 200;
    const halts = [{ s: 50, dur: 2.2 }, { s: 150, dur: 2.2 }];
    // Deterministic.
    assert.equal(odometer(cruise, halts, L, 10), odometer(cruise, halts, L, 10));
    // Unpaused stretch advances at gait.
    assert.ok(Math.abs(odometer(cruise, halts, L, 10) - cruise * 10) < 1e-9, 'gait wrong');
    // Arrival holds: from t_a to t_a+dur the reading stays on the loot.
    const ta = 50 / cruise;
    assert.ok(Math.abs(odometer(cruise, halts, L, ta + 1.1) - 50) < 1e-9, 'halt does not hold');
    assert.ok(Math.abs(odometer(cruise, halts, L, ta + 2.2) - 50) < 1e-9, 'halt releases early');
    // Monotonic everywhere, both gaits, both halt sets.
    for (const c of [0.4, 1.4, 2.6]) {
        let prev = odometer(c, halts, L, 0);
        for (let t = 0.05; t < 300; t += 0.05) {
            const s = odometer(c, halts, L, t);
            const d = (s - prev + L) % L;
            assert.ok(d < c * 0.06 + 1e-9, `retreat at t=${t.toFixed(2)} (cruise ${c})`);
            prev = s;
        }
    }
});

test('entity poses are deterministic, bounded and hero-aware', () => {
    const m = genDungeon({ seed: 7, rng: new Rng(7) });
    const L = m.route.totalLen;
    for (const e of m.items.entities) {
        const p1 = entityPose(e, 10, 5, 0, 0, L);
        const p2 = entityPose(e, 10, 5, 0, 0, L);
        assert.deepEqual(p1, p2, `${e.kind} pose unstable`);
        assert.ok(Math.hypot(p1.x - e.x, p1.z - e.z) <= e.range + 1.6,
            `${e.kind} wanders ${Math.hypot(p1.x - e.x, p1.z - e.z).toFixed(2)} from home`);
        assert.ok(p1.alert >= 0 && p1.alert <= 1, `${e.kind} alert out of range`);
        // Near the hero it notices; far away it doesn't.
        const near = entityPose(e, 10, e.s, e.x, e.z, L);
        const far = entityPose(e, 10, (e.s + L / 2) % L, e.x, e.z, L);
        assert.ok(near.alert >= far.alert, `${e.kind} ignores the hero`);
        assert.ok(near.alert > 0.5, `${e.kind} cold at point blank`);
    }
});

const SLOW_DARK = {
    meanCentroid: 0.3, meanFlatness: 0.1, bpm: 68,
    dynamicRange: 0.7, meanLoudness: 0.3,
};

function slowPersonalityAt(seed) {
    const rng = new Rng(seed);
    return generatePersonality(SLOW_DARK, rng.fork('personality'), () => 10, 4);
}

test('VenueGenerator plans the dungeon map when the dungeon is picked', () => {
    const rng = new Rng(5);
    const story = {
        sections: [{ act: 'setup' }, { act: 'development' }, { act: 'climax' }, { act: 'resolution' }],
    };
    const vs = generateVenue({
        summary: SLOW_DARK, rng: rng.fork('venue'), personality: slowPersonalityAt(5),
        director: null, story, sections: [{}, {}, {}, {}],
    });
    assert.equal(vs.archetype, 'dungeon');
    assert.ok(vs.dungeon && vs.dungeon.map, 'dungeon venue must carry the map');
    assert.ok(vs.dungeon.map.rooms.length >= 3, 'map has no rooms');
    assert.ok(vs.dungeon.map.route.totalLen > 80, 'route too short');
    assert.equal(vs.population.kind, 'party', 'dungeon walks a party, not a crowd');
    assert.equal(vs.projection.kind, 'portal', 'dungeon projects on the portal');
    // Deterministic across regenerations.
    const again = generateVenue({
        summary: SLOW_DARK, rng: new Rng(5).fork('venue'), personality: slowPersonalityAt(5),
        director: null, story, sections: [{}, {}, {}, {}],
    });
    assert.deepEqual(again.dungeon, vs.dungeon);
    // Non-dungeon venues carry no dungeon plan.
    const fast = generateVenue({
        summary: { ...SLOW_DARK, bpm: 140 }, rng: new Rng(5).fork('venue'),
        personality: slowPersonalityAt(5), director: null, story, sections: [{}, {}, {}, {}],
    });
    if (fast.archetype !== 'dungeon') assert.equal(fast.dungeon, null);
});