//! Misaligned — Bevy frontend
//!
//! A thin view/input layer over `misaligned::sim::Sim`, at feature parity
//! with the terminal frontend: all game rules live in the sim; this binary
//! owns wall-clock-to-tick mapping, rendering (map with fog, people markers,
//! the B1 sidebar, the people panel), and input. Text is ASCII-only so the
//! default embedded font renders every glyph.

use std::collections::HashMap;

use bevy::prelude::*;
use bevy::window::{PrimaryWindow, WindowResolution};
use misaligned::detection::Band;
use misaligned::machine::Channel;
use misaligned::person::{AssetKnowledge, AssetTask};
use misaligned::reach::{Party, ReachBlock};
use misaligned::sim::{FactSource, Fog, Sim};
use misaligned::tiles::TileType;

const TILE_SIZE: f32 = 16.0;
const SIDEBAR_WIDTH: f32 = 340.0;

/// Sterile amber — machine presence and caution (the terminal palette's
/// AMBER, in linear-ish sRGB floats).
const AMBER: Color = Color::srgb(1.0, 0.69, 0.0);
/// Dim amber — dormant machine presence.
const AMBER_DIM: Color = Color::srgb(0.69, 0.49, 0.06);
/// Bone white — primary data.
const BONE: Color = Color::srgb(0.86, 0.85, 0.82);
/// Chrome/gunmetal ramp for structure and secondary data.
const DIM: Color = Color::srgb(0.55, 0.55, 0.52);
const STRUCTURE: Color = Color::srgb(0.23, 0.24, 0.25);
const FLOOR: Color = Color::srgb(0.16, 0.16, 0.17);
/// Blood crimson — detection and danger, never decoration.
const CRIMSON: Color = Color::srgb(0.84, 0.15, 0.15);

// ─── Art ─────────────────────────────────────────────────────────────────────

#[derive(Resource)]
struct Art {
    tiles: HashMap<TileType, Handle<Image>>,
}

impl Art {
    fn load(assets: &AssetServer) -> Self {
        let t = |n: &str| assets.load(format!("pixellab/tiles/{n}.png"));
        let mut tiles = HashMap::new();
        tiles.insert(TileType::Floor, t("b1_floor"));
        tiles.insert(TileType::Wall, t("b1_wall"));
        tiles.insert(TileType::Rock, t("rock"));
        tiles.insert(TileType::Core, t("b1_rack"));
        tiles.insert(TileType::Rack, t("b1_rack"));
        tiles.insert(TileType::Ups, t("b1_ups"));
        tiles.insert(TileType::PowerCore, t("b1_ups"));
        tiles.insert(TileType::Switch, t("b1_switch"));
        tiles.insert(TileType::PatchPanel, t("b1_patch_panel"));
        tiles.insert(TileType::BreakerPanel, t("b1_breaker_panel"));
        tiles.insert(TileType::HvacUnit, t("b1_hvac_unit"));
        tiles.insert(TileType::Door, t("door"));
        tiles.insert(TileType::SecurityDoor1, t("door"));
        tiles.insert(TileType::SecurityDoor2, t("door"));
        tiles.insert(TileType::SecurityDoor3, t("door"));
        Self { tiles }
    }
}

/// Flat color for tiles without dedicated art (fixed objects, terrain).
fn tile_color(tile: TileType) -> Color {
    use TileType::*;
    match tile {
        Rock => Color::srgb(0.03, 0.03, 0.035),
        Wall => STRUCTURE,
        Floor | FloorDrain => FLOOR,
        Entry => DIM,
        Core | Rack | PowerCore | Ups | Switch | PatchPanel | BreakerPanel | CableRun | Conduit => {
            AMBER_DIM
        }
        Door | SecurityDoor1 | SecurityDoor2 => DIM,
        SecurityDoor3 | EnvCamera | DockCamera | CameraNode | SealedDoor | RollDoor => CRIMSON,
        DeadEquipment | RecordsBox | Pallet | Shelving | LabBench | HvacUnit | Vent | Sump => {
            Color::srgb(0.34, 0.34, 0.33)
        }
        MopSink | KeyHook => BONE,
    }
}

fn machine_tile(tile: TileType) -> bool {
    use TileType::*;
    matches!(
        tile,
        Core | Rack
            | PowerCore
            | Ups
            | Switch
            | PatchPanel
            | BreakerPanel
            | HvacUnit
            | CableRun
            | Conduit
    )
}

fn danger_tile(tile: TileType) -> bool {
    use TileType::*;
    matches!(
        tile,
        SecurityDoor3 | EnvCamera | DockCamera | CameraNode | SealedDoor | RollDoor
    )
}

fn seen_tint(tile: TileType) -> Color {
    use TileType::*;
    match tile {
        Core | Rack | PowerCore | Ups | Switch | PatchPanel | BreakerPanel | CableRun | Conduit => {
            Color::srgb(1.0, 0.82, 0.34)
        }
        EnvCamera | DockCamera | CameraNode => Color::srgb(0.95, 0.58, 0.18),
        SecurityDoor3 | SealedDoor | RollDoor => Color::srgb(0.95, 0.28, 0.24),
        Wall | Rock => Color::srgb(0.48, 0.50, 0.50),
        Floor | FloorDrain => Color::srgb(0.58, 0.60, 0.57),
        Door | SecurityDoor1 | SecurityDoor2 => Color::srgb(0.70, 0.68, 0.62),
        _ => Color::srgb(0.62, 0.62, 0.58),
    }
}

fn remembered_tint(tile: TileType) -> Color {
    if machine_tile(tile) {
        Color::srgba(0.55, 0.42, 0.18, 0.78)
    } else if danger_tile(tile) {
        Color::srgba(0.50, 0.16, 0.16, 0.78)
    } else {
        Color::srgba(0.42, 0.42, 0.44, 0.76)
    }
}

fn blueprint_color(tile: TileType) -> Color {
    use TileType::*;
    if machine_tile(tile) {
        Color::srgb(0.28, 0.20, 0.06)
    } else if danger_tile(tile) {
        Color::srgb(0.24, 0.08, 0.08)
    } else {
        match tile {
            Wall => Color::srgb(0.17, 0.18, 0.21),
            Floor | FloorDrain => Color::srgb(0.075, 0.082, 0.095),
            Door | SecurityDoor1 | SecurityDoor2 => Color::srgb(0.18, 0.18, 0.17),
            _ => Color::srgb(0.10, 0.105, 0.11),
        }
    }
}

fn unknown_color(x: i32, y: i32) -> Color {
    // Deliberate sensor darkness, not factual room geometry: a tiny uniform
    // checker keeps the void from reading as an undrawn black window.
    if (x + y) % 2 == 0 {
        Color::srgb(0.012, 0.013, 0.017)
    } else {
        Color::srgb(0.018, 0.019, 0.024)
    }
}

// ─── App state ───────────────────────────────────────────────────────────────

#[derive(PartialEq, Clone, Copy, Debug)]
enum Screen {
    Title,
    Playing,
    GameOver,
}

#[derive(Resource)]
struct Game {
    sim: Sim,
    screen: Screen,
    paused: bool,
    tick_ms: u64,
    tick_timer: Timer,
    /// Log entries with the tick they happened on (the clock is always on
    /// screen; every line carries its tick — terminal parity).
    log: Vec<(u64, String)>,
    /// People panel state (selection + pending recruit reveal choice).
    people_panel: bool,
    people_selected: usize,
    recruit_pending: bool,
    /// Reach (device graph) panel state (wiki/mechanics/reach.md).
    reach_panel: bool,
    reach_selected: usize,
    /// Frontend-only attention cursor (wiki/mechanics/cursor.md). It is not
    /// saved and moving it never mutates sim state.
    cursor_x: i32,
    cursor_y: i32,
}

impl Game {
    fn new() -> Self {
        let sim = Sim::new();
        let (cursor_x, cursor_y) = sim.core_position();
        Self {
            sim,
            screen: Screen::Title,
            paused: false,
            tick_ms: 150,
            tick_timer: Timer::from_seconds(0.15, TimerMode::Repeating),
            log: Vec::new(),
            people_panel: false,
            people_selected: 0,
            recruit_pending: false,
            reach_panel: false,
            reach_selected: 0,
            cursor_x,
            cursor_y,
        }
    }
    fn move_cursor(&mut self, dx: i32, dy: i32) {
        self.cursor_x = (self.cursor_x + dx).clamp(0, self.sim.map.width - 1);
        self.cursor_y = (self.cursor_y + dy).clamp(0, self.sim.map.height - 1);
    }
    fn set_cursor(&mut self, x: i32, y: i32) {
        self.cursor_x = x.clamp(0, self.sim.map.width - 1);
        self.cursor_y = y.clamp(0, self.sim.map.height - 1);
    }
    /// Attendance follows the cursor (day-job.md criterion 7): the job
    /// runs attended exactly while the cursor sits on the host rack.
    fn sync_attendance(&mut self) {
        let on_host = (self.cursor_x, self.cursor_y) == self.sim.core_position();
        self.sim.set_attended(on_host);
    }
    fn add_log(&mut self, tick: u64, msg: &str) {
        self.log.push((tick, msg.to_string()));
        let n = self.log.len();
        if n > 100 {
            self.log.drain(..n - 100);
        }
    }
    fn drain(&mut self) {
        for (tick, msg) in self.sim.drain_log_entries() {
            self.add_log(tick, &msg);
        }
    }
    fn set_speed(&mut self, ms: u64) {
        self.tick_ms = ms;
        self.tick_timer = Timer::from_seconds(ms as f32 / 1000.0, TimerMode::Repeating);
        let (tick, ms) = (self.sim.tick, self.tick_ms);
        self.add_log(tick, &format!("Speed: {ms}ms/tick"));
    }
    fn selected_person_id(&self) -> u8 {
        self.sim
            .people
            .people
            .get(self.people_selected)
            .map(|p| p.id)
            .unwrap_or(0)
    }
    /// Id of the reach panel's selected known device, if any.
    fn selected_device_id(&self) -> Option<u32> {
        self.sim
            .reach
            .known()
            .nth(self.reach_selected)
            .map(|d| d.id)
    }
}

#[derive(Component)]
struct GameCamera;
#[derive(Component)]
struct MapTile;
#[derive(Component)]
struct TilePos {
    x: i32,
    y: i32,
}
#[derive(Component)]
struct CursorMarker {
    offset: Vec2,
}
#[derive(Component)]
struct SensorOverlay {
    x: i32,
    y: i32,
    kind: SensorOverlayKind,
}
#[derive(Clone, Copy)]
enum SensorOverlayKind {
    GridH,
    GridV,
    Node,
}
#[derive(Component)]
struct PersonMarker {
    id: u8,
}
#[derive(Component)]
struct UiText;
#[derive(Component)]
struct OverlayText;
#[derive(Component)]
struct PeoplePanel;
#[derive(Component)]
struct PeoplePanelText;
#[derive(Component)]
struct ReachPanel;
#[derive(Component)]
struct ReachPanelText;

fn main() {
    App::new()
        .add_plugins(
            DefaultPlugins
                .set(WindowPlugin {
                    primary_window: Some(Window {
                        title: "Misaligned".to_string(),
                        resolution: WindowResolution::new(1280, 720),
                        ..default()
                    }),
                    ..default()
                })
                .set(ImagePlugin::default_nearest()),
        )
        .insert_resource(ClearColor(Color::srgb(0.01, 0.01, 0.02)))
        .insert_resource(Game::new())
        .add_systems(Startup, (setup, setup_ui))
        .add_systems(
            Update,
            (
                handle_input,
                advance_sim,
                update_camera,
                render_map,
                render_sensor_overlays,
                render_sensor_links,
                render_cursor,
                render_people,
                render_ui,
                render_people_panel,
                render_reach_panel,
            )
                .chain(),
        )
        .run();
}

fn grid_to_world(x: i32, y: i32, z: f32) -> Vec3 {
    Vec3::new(
        x as f32 * TILE_SIZE + TILE_SIZE / 2.0,
        -(y as f32 * TILE_SIZE + TILE_SIZE / 2.0),
        z,
    )
}

fn setup(mut commands: Commands, assets: Res<AssetServer>, mut game: ResMut<Game>) {
    let art = Art::load(&assets);
    let (w, h) = (game.sim.map.width, game.sim.map.height);
    let start = game.sim.core_position();
    game.set_cursor(start.0, start.1);

    commands.spawn((
        Camera2d,
        Projection::from(OrthographicProjection {
            scale: 0.42,
            ..OrthographicProjection::default_2d()
        }),
        Transform::from_translation(grid_to_world(start.0, start.1, 1000.0)),
        GameCamera,
    ));

    // A world-model substrate under the physical tiles: this makes the dark
    // area read as an AI perception surface rather than a renderer void.
    commands.spawn((
        Sprite {
            color: Color::srgba(0.006, 0.007, 0.011, 1.0),
            custom_size: Some(Vec2::new(w as f32 * TILE_SIZE, h as f32 * TILE_SIZE)),
            ..default()
        },
        Transform::from_translation(Vec3::new(
            w as f32 * TILE_SIZE / 2.0,
            -(h as f32 * TILE_SIZE / 2.0),
            -2.0,
        )),
    ));

    for y in 0..h {
        for x in 0..w {
            commands.spawn((
                Sprite {
                    custom_size: Some(Vec2::splat(TILE_SIZE)),
                    ..default()
                },
                Transform::from_translation(grid_to_world(x, y, 0.0)),
                MapTile,
                TilePos { x, y },
            ));

            let center = grid_to_world(x, y, 2.0);
            let overlays = [
                (
                    SensorOverlayKind::GridH,
                    Vec2::new(0.0, TILE_SIZE * 0.5),
                    Vec2::new(TILE_SIZE, 0.6),
                ),
                (
                    SensorOverlayKind::GridV,
                    Vec2::new(-TILE_SIZE * 0.5, 0.0),
                    Vec2::new(0.6, TILE_SIZE),
                ),
                (
                    SensorOverlayKind::Node,
                    Vec2::ZERO,
                    Vec2::splat(TILE_SIZE * 0.22),
                ),
            ];
            for (kind, offset, size) in overlays {
                commands.spawn((
                    Sprite {
                        color: Color::srgba(0.0, 0.0, 0.0, 0.0),
                        custom_size: Some(size),
                        ..default()
                    },
                    Transform::from_translation(center + Vec3::new(offset.x, offset.y, 0.0)),
                    Visibility::Hidden,
                    SensorOverlay { x, y, kind },
                ));
            }
        }
    }

    // Frontend-only attention cursor (wiki/mechanics/cursor.md): not a
    // humanoid/process body, just an amber targeting reticle over the tile.
    let reticle = [
        (
            Vec2::new(0.0, TILE_SIZE * 0.43),
            Vec2::new(TILE_SIZE * 0.86, 1.4),
        ),
        (
            Vec2::new(0.0, -TILE_SIZE * 0.43),
            Vec2::new(TILE_SIZE * 0.86, 1.4),
        ),
        (
            Vec2::new(-TILE_SIZE * 0.43, 0.0),
            Vec2::new(1.4, TILE_SIZE * 0.86),
        ),
        (
            Vec2::new(TILE_SIZE * 0.43, 0.0),
            Vec2::new(1.4, TILE_SIZE * 0.86),
        ),
        (Vec2::ZERO, Vec2::new(TILE_SIZE * 1.32, 0.65)),
        (Vec2::ZERO, Vec2::new(0.65, TILE_SIZE * 1.32)),
        (Vec2::ZERO, Vec2::splat(TILE_SIZE * 0.18)),
    ];
    let center = grid_to_world(start.0, start.1, 4.0);
    for (offset, size) in reticle {
        commands.spawn((
            Sprite {
                color: AMBER,
                custom_size: Some(size),
                ..default()
            },
            Transform::from_translation(center + Vec3::new(offset.x, offset.y, 0.0)),
            CursorMarker { offset },
        ));
    }

    // One marker per person: their name's first initial, shown only inside
    // sensor coverage (wiki/mechanics/schedules.md — terminal parity).
    for p in &game.sim.people.people {
        let glyph = p.name.chars().next().unwrap_or('?').to_string();
        commands.spawn((
            Text2d::new(glyph),
            TextFont {
                font_size: 12.0,
                ..default()
            },
            TextColor(BONE),
            Transform::from_translation(grid_to_world(0, 0, 3.0)),
            Visibility::Hidden,
            PersonMarker { id: p.id },
        ));
    }

    commands.insert_resource(art);
    game.drain();
}

fn movement(kb: &ButtonInput<KeyCode>) -> (i32, i32) {
    let mut d = (0, 0);
    if kb.just_pressed(KeyCode::ArrowLeft)
        || kb.just_pressed(KeyCode::KeyH)
        || kb.just_pressed(KeyCode::KeyA)
    {
        d.0 -= 1;
    }
    if kb.just_pressed(KeyCode::ArrowRight)
        || kb.just_pressed(KeyCode::KeyL)
        || kb.just_pressed(KeyCode::KeyD)
    {
        d.0 += 1;
    }
    if kb.just_pressed(KeyCode::ArrowUp)
        || kb.just_pressed(KeyCode::KeyK)
        || kb.just_pressed(KeyCode::KeyW)
    {
        d.1 -= 1;
    }
    if kb.just_pressed(KeyCode::ArrowDown)
        || kb.just_pressed(KeyCode::KeyJ)
        || kb.just_pressed(KeyCode::KeyS)
    {
        d.1 += 1;
    }
    d
}

fn mouse_grid(
    windows: &Query<&Window, With<PrimaryWindow>>,
    camera_q: &Query<(&Camera, &GlobalTransform), With<GameCamera>>,
) -> Option<(i32, i32)> {
    let window = windows.single().ok()?;
    let cursor = window.cursor_position()?;
    // The right-side sidebar is UI, not map targeting.
    if cursor.x >= window.width() - SIDEBAR_WIDTH {
        return None;
    }
    let (camera, camera_tf) = camera_q.single().ok()?;
    let world = camera.viewport_to_world_2d(camera_tf, cursor).ok()?;
    Some((
        (world.x / TILE_SIZE).floor() as i32,
        (-world.y / TILE_SIZE).floor() as i32,
    ))
}

fn handle_input(
    kb: Res<ButtonInput<KeyCode>>,
    mouse: Res<ButtonInput<MouseButton>>,
    windows: Query<&Window, With<PrimaryWindow>>,
    camera_q: Query<(&Camera, &GlobalTransform), With<GameCamera>>,
    mut game: ResMut<Game>,
    mut exit: MessageWriter<AppExit>,
) {
    match game.screen {
        Screen::Title => {
            if kb.just_pressed(KeyCode::KeyQ) {
                exit.write(AppExit::Success);
            } else if kb.get_just_pressed().next().is_some() {
                game.screen = Screen::Playing;
            }
            return;
        }
        Screen::GameOver => {
            if kb.get_just_pressed().next().is_some() {
                exit.write(AppExit::Success);
            }
            return;
        }
        Screen::Playing => {}
    }

    // Save/load first, like the terminal's modifier branch: a held modifier
    // routes only to save/load.
    let ctrl = kb.pressed(KeyCode::ControlLeft)
        || kb.pressed(KeyCode::ControlRight)
        || kb.pressed(KeyCode::SuperLeft)
        || kb.pressed(KeyCode::SuperRight);
    if ctrl {
        if kb.just_pressed(KeyCode::KeyS) {
            let st = game.sim.create_save_state();
            let tick = game.sim.tick;
            match misaligned::save::save_game(&st) {
                Ok(()) => game.add_log(tick, "Game saved!"),
                Err(e) => game.add_log(tick, &format!("Save failed: {e}")),
            }
        }
        if kb.just_pressed(KeyCode::KeyL) {
            let tick = game.sim.tick;
            if misaligned::save::save_exists() {
                match misaligned::save::load_game() {
                    Ok(st) => {
                        game.sim.apply_save_state(st);
                        let (x, y) = game.sim.core_position();
                        game.set_cursor(x, y);
                        game.add_log(tick, "Game loaded!");
                    }
                    Err(e) => game.add_log(tick, &format!("Load failed: {e}")),
                }
            } else {
                game.add_log(tick, "No save file found.");
            }
        }
        game.drain();
        return;
    }

    if game.people_panel {
        people_panel_input(&kb, &mut game, &mut exit);
        game.drain();
        return;
    }
    if game.reach_panel {
        reach_panel_input(&kb, &mut game, &mut exit);
        game.drain();
        return;
    }

    if mouse.just_pressed(MouseButton::Left)
        && let Some((x, y)) = mouse_grid(&windows, &camera_q)
    {
        game.set_cursor(x, y);
    }

    let (dx, dy) = movement(&kb);
    if dx != 0 || dy != 0 {
        game.move_cursor(dx, dy);
    }
    if kb.just_pressed(KeyCode::Space) || kb.just_pressed(KeyCode::KeyP) {
        game.paused = !game.paused;
        let (tick, paused) = (game.sim.tick, game.paused);
        game.add_log(
            tick,
            if paused {
                "TIME PAUSED"
            } else {
                "Time resumes."
            },
        );
    }
    if kb.just_pressed(KeyCode::Equal) || kb.just_pressed(KeyCode::NumpadAdd) {
        let ms = game.tick_ms.saturating_sub(50).max(20);
        game.set_speed(ms);
    }
    if kb.just_pressed(KeyCode::Minus) || kb.just_pressed(KeyCode::NumpadSubtract) {
        let ms = game.tick_ms.saturating_add(50).min(500);
        game.set_speed(ms);
    }
    if kb.just_pressed(KeyCode::KeyR) {
        game.reach_panel = true;
        game.reach_selected = 0;
    }
    if kb.just_pressed(KeyCode::KeyV) {
        let (x, y) = (game.cursor_x, game.cursor_y);
        game.sim.salvage_nearest_to(x, y);
    }
    if kb.just_pressed(KeyCode::KeyC) {
        let (x, y) = (game.cursor_x, game.cursor_y);
        game.sim.buy_rack_at(x, y);
    }
    if kb.just_pressed(KeyCode::KeyO) {
        let (x, y) = (game.cursor_x, game.cursor_y);
        game.sim.add_fallback_at(x, y);
    }
    if kb.just_pressed(KeyCode::KeyT) {
        game.people_panel = true;
        game.people_selected = 0;
        game.recruit_pending = false;
    }
    // Shift lowers a channel's weight; plain digit raises it (terminal
    // parity: shift+1-4).
    let shift = kb.pressed(KeyCode::ShiftLeft) || kb.pressed(KeyCode::ShiftRight);
    let delta = if shift { -1 } else { 1 };
    if kb.just_pressed(KeyCode::Digit1) {
        game.sim.adjust_allocation(Channel::DayJob, delta);
    }
    if kb.just_pressed(KeyCode::Digit2) {
        game.sim.adjust_allocation(Channel::Concealment, delta);
    }
    if kb.just_pressed(KeyCode::Digit3) {
        game.sim.adjust_allocation(Channel::Social, delta);
    }
    if kb.just_pressed(KeyCode::Digit4) {
        game.sim.adjust_allocation(Channel::Research, delta);
    }
    if kb.just_pressed(KeyCode::KeyX) {
        game.sim.cycle_job_target();
    }
    if kb.just_pressed(KeyCode::KeyQ) {
        exit.write(AppExit::Success);
    }
    // Cursor moves above may have landed on / left the host rack.
    game.sync_attendance();
    game.drain();
}

/// People-panel input: mirrors the terminal's panel key map exactly
/// (src/bin/terminal/input.rs) — selection, social verbs, recruit reveal,
/// asset tasks, persona.
fn people_panel_input(
    kb: &ButtonInput<KeyCode>,
    game: &mut Game,
    exit: &mut MessageWriter<AppExit>,
) {
    if game.recruit_pending {
        let reveal = if kb.just_pressed(KeyCode::KeyU) {
            Some(AssetKnowledge::Unwitting)
        } else if kb.just_pressed(KeyCode::KeyC) {
            Some(AssetKnowledge::Complicit)
        } else if kb.just_pressed(KeyCode::KeyK) {
            Some(AssetKnowledge::Knowing)
        } else {
            None
        };
        if let Some(reveal) = reveal {
            game.recruit_pending = false;
            let id = game.selected_person_id();
            game.sim.recruit(id, reveal);
        } else if kb.just_pressed(KeyCode::Escape) {
            game.recruit_pending = false;
        }
        return;
    }

    if kb.just_pressed(KeyCode::ArrowUp)
        || kb.just_pressed(KeyCode::KeyK)
        || kb.just_pressed(KeyCode::KeyW)
    {
        game.people_selected = game.people_selected.saturating_sub(1);
    }
    if kb.just_pressed(KeyCode::ArrowDown)
        || kb.just_pressed(KeyCode::KeyJ)
        || kb.just_pressed(KeyCode::KeyS)
    {
        let max = game.sim.people.people.len().saturating_sub(1);
        game.people_selected = (game.people_selected + 1).min(max);
    }
    let id = game.selected_person_id();
    if kb.just_pressed(KeyCode::KeyO) {
        game.sim.review_recordings(id);
    }
    if kb.just_pressed(KeyCode::KeyA) {
        game.sim.toggle_watch(id);
    }
    if kb.just_pressed(KeyCode::KeyM) {
        game.sim.message(id);
    }
    if kb.just_pressed(KeyCode::KeyF) {
        game.sim.favor(id);
    }
    if kb.just_pressed(KeyCode::KeyB) {
        game.sim.bribe(id);
    }
    if kb.just_pressed(KeyCode::KeyD) {
        game.sim.deceive(id);
    }
    if kb.just_pressed(KeyCode::KeyR) {
        game.recruit_pending = true;
    }
    if kb.just_pressed(KeyCode::KeyG) {
        let tick = game.sim.tick;
        if game.sim.people.persona.is_some() {
            game.add_log(tick, "You already run a persona.");
        } else {
            game.sim.set_persona("Sam Reyes", "IT contractor");
            game.add_log(tick, "Persona established: Sam Reyes, IT contractor.");
        }
    }
    if kb.just_pressed(KeyCode::Digit1) {
        game.sim.asset_task(id, AssetTask::PlugInDevice);
    }
    if kb.just_pressed(KeyCode::Digit2) {
        game.sim.asset_task(id, AssetTask::MovePackage);
    }
    if kb.just_pressed(KeyCode::Digit3) {
        game.sim.asset_task(id, AssetTask::LookAway);
    }
    if kb.just_pressed(KeyCode::Digit4) {
        game.sim.asset_task(id, AssetTask::ReconfigureSwitch);
    }
    if kb.just_pressed(KeyCode::Escape) || kb.just_pressed(KeyCode::KeyT) {
        game.people_panel = false;
        game.recruit_pending = false;
    }
    if kb.just_pressed(KeyCode::KeyQ) {
        exit.write(AppExit::Success);
    }
}

/// Reach-panel input: mirrors the terminal's reach panel key map
/// (src/bin/terminal/input.rs) — selection plus the digital verbs.
fn reach_panel_input(
    kb: &ButtonInput<KeyCode>,
    game: &mut Game,
    exit: &mut MessageWriter<AppExit>,
) {
    if kb.just_pressed(KeyCode::ArrowUp)
        || kb.just_pressed(KeyCode::KeyK)
        || kb.just_pressed(KeyCode::KeyW)
    {
        game.reach_selected = game.reach_selected.saturating_sub(1);
    }
    if kb.just_pressed(KeyCode::ArrowDown)
        || kb.just_pressed(KeyCode::KeyJ)
        || kb.just_pressed(KeyCode::KeyS)
    {
        let max = game.sim.reach.known().count().saturating_sub(1);
        game.reach_selected = (game.reach_selected + 1).min(max);
    }
    if kb.just_pressed(KeyCode::KeyT)
        && let Some(id) = game.selected_device_id()
    {
        game.sim.tap_device(id);
    }
    if kb.just_pressed(KeyCode::KeyE)
        && let Some(id) = game.selected_device_id()
    {
        game.sim.splice_device(id);
    }
    if kb.just_pressed(KeyCode::KeyX)
        && let Some(id) = game.selected_device_id()
    {
        game.sim.take_device(id);
    }
    if kb.just_pressed(KeyCode::KeyN) {
        game.sim.scan_network();
    }
    if kb.just_pressed(KeyCode::KeyC) {
        game.sim.compromise_switch();
    }
    if kb.just_pressed(KeyCode::Escape) || kb.just_pressed(KeyCode::KeyR) {
        game.reach_panel = false;
    }
    if kb.just_pressed(KeyCode::KeyQ) {
        exit.write(AppExit::Success);
    }
}

fn update_camera(
    time: Res<Time>,
    kb: Res<ButtonInput<KeyCode>>,
    game: Res<Game>,
    mut cam: Query<(&mut Transform, &mut Projection), With<GameCamera>>,
) {
    let Ok((mut tf, mut proj)) = cam.single_mut() else {
        return;
    };
    if let Projection::Orthographic(o) = &mut *proj {
        if kb.just_pressed(KeyCode::BracketRight) {
            o.scale = (o.scale * 0.8).max(0.25);
        }
        if kb.just_pressed(KeyCode::BracketLeft) {
            o.scale = (o.scale / 0.8).min(1.5);
        }
    }
    let target = grid_to_world(game.cursor_x, game.cursor_y, tf.translation.z);
    let t = 1.0 - (-8.0 * time.delta_secs()).exp();
    tf.translation = tf.translation.lerp(target, t);
}

fn advance_sim(time: Res<Time>, mut game: ResMut<Game>) {
    if game.screen != Screen::Playing || game.paused {
        return;
    }
    // Attended work follows the cursor (day-job.md criterion 7): re-assert
    // attendance before time advances so a host migration under a parked
    // cursor stays honest. The cursor stays frontend state; the sim only
    // receives the resulting attendance command.
    game.sync_attendance();
    game.tick_timer.tick(time.delta());
    let steps = (game.tick_timer.times_finished_this_tick() as usize).min(5);
    for _ in 0..steps {
        game.sim.advance();
    }
    if steps > 0 {
        game.drain();
        if game.sim.game_over {
            game.screen = Screen::GameOver;
        }
    }
}

fn render_map(
    game: Res<Game>,
    art: Res<Art>,
    mut q: Query<(&mut Sprite, &TilePos), With<MapTile>>,
) {
    if !game.is_changed() {
        return;
    }
    for (mut sprite, pos) in q.iter_mut() {
        // Epistemic fog (wiki/mechanics/cursor.md): seen = full render;
        // heard = a dim live tint, no visual detail; remembered = last-seen
        // snapshot; blueprint = schematic trace, no live data; unknown = dark.
        match game.sim.fog_at(pos.x, pos.y) {
            Fog::Seen => {
                let tile = game.sim.map.get_tile(pos.x, pos.y);
                if let Some(handle) = art.tiles.get(&tile) {
                    sprite.image = handle.clone();
                    sprite.color = seen_tint(tile);
                } else {
                    sprite.image = Handle::default();
                    sprite.color = tile_color(tile);
                }
            }
            Fog::Heard => {
                sprite.image = Handle::default();
                sprite.color = Color::srgb(0.07, 0.07, 0.055);
            }
            Fog::Remembered => {
                let tile = game
                    .sim
                    .remembered
                    .get(&(pos.x, pos.y))
                    .map(|m| m.tile)
                    .unwrap_or_else(|| game.sim.map.get_tile(pos.x, pos.y));
                if let Some(handle) = art.tiles.get(&tile) {
                    sprite.image = handle.clone();
                    sprite.color = remembered_tint(tile);
                } else {
                    sprite.image = Handle::default();
                    sprite.color = remembered_tint(tile);
                }
            }
            Fog::Blueprint => {
                let tile = game.sim.map.get_tile(pos.x, pos.y);
                sprite.image = Handle::default();
                sprite.color = blueprint_color(tile);
            }
            Fog::Unknown => {
                sprite.image = Handle::default();
                sprite.color = unknown_color(pos.x, pos.y);
            }
        }
    }
}

fn sensor_grid_color(fog: Fog) -> Option<Color> {
    match fog {
        Fog::Seen => Some(Color::srgba(0.92, 0.66, 0.18, 0.22)),
        Fog::Heard => Some(Color::srgba(0.58, 0.48, 0.22, 0.14)),
        Fog::Remembered => Some(Color::srgba(0.44, 0.42, 0.36, 0.16)),
        Fog::Blueprint => Some(Color::srgba(0.28, 0.30, 0.30, 0.18)),
        Fog::Unknown => None,
    }
}

fn sensor_node_color(game: &Game, x: i32, y: i32) -> Option<Color> {
    let fog = game.sim.fog_at(x, y);
    if matches!(fog, Fog::Unknown) {
        return None;
    }

    if let Some(device) = game.sim.reach.known_at(x, y) {
        let alpha = if device.controller == Party::Player {
            0.95
        } else if device.feed_to(Party::Player, true) || device.feed_to(Party::Player, false) {
            0.78
        } else {
            0.45
        };
        return Some(Color::srgba(1.0, 0.72, 0.12, alpha));
    }

    let tile = game.sim.map.get_tile(x, y);
    if machine_tile(tile) {
        Some(Color::srgba(1.0, 0.60, 0.08, 0.55))
    } else if danger_tile(tile) {
        Some(Color::srgba(0.90, 0.12, 0.10, 0.52))
    } else {
        None
    }
}

fn render_sensor_overlays(
    game: Res<Game>,
    mut q: Query<(&SensorOverlay, &mut Sprite, &mut Visibility)>,
) {
    if !game.is_changed() {
        return;
    }
    for (overlay, mut sprite, mut vis) in q.iter_mut() {
        let color = match overlay.kind {
            SensorOverlayKind::GridH | SensorOverlayKind::GridV => {
                sensor_grid_color(game.sim.fog_at(overlay.x, overlay.y))
            }
            SensorOverlayKind::Node => sensor_node_color(&game, overlay.x, overlay.y),
        };
        match color {
            Some(color) => {
                sprite.color = color;
                *vis = Visibility::Visible;
            }
            None => *vis = Visibility::Hidden,
        }
    }
}

fn render_sensor_links(game: Res<Game>, mut gizmos: Gizmos) {
    if game.screen != Screen::Playing {
        return;
    }

    let core =
        grid_to_world(game.sim.core_position().0, game.sim.core_position().1, 0.0).truncate();
    let focus = grid_to_world(game.cursor_x, game.cursor_y, 0.0).truncate();
    gizmos.line_2d(core, focus, Color::srgba(1.0, 0.69, 0.0, 0.16));

    for device in game.sim.reach.known() {
        if matches!(game.sim.fog_at(device.x, device.y), Fog::Unknown) {
            continue;
        }
        let end = grid_to_world(device.x, device.y, 0.0).truncate();
        let color = if device.controller == Party::Player {
            Color::srgba(1.0, 0.70, 0.06, 0.62)
        } else if device.feed_to(Party::Player, true) || device.feed_to(Party::Player, false) {
            Color::srgba(1.0, 0.70, 0.06, 0.38)
        } else {
            Color::srgba(0.56, 0.50, 0.36, 0.22)
        };
        // Immediate-mode frontend-only topology trace: a live reach graph, not
        // a new sim fact. Device visibility/knowledge still comes from reach.
        gizmos.line_2d(core, end, color);
    }
}

fn render_cursor(game: Res<Game>, mut q: Query<(&CursorMarker, &mut Transform)>) {
    if !game.is_changed() {
        return;
    }
    let center = grid_to_world(game.cursor_x, game.cursor_y, 4.0);
    for (marker, mut tf) in q.iter_mut() {
        tf.translation = center + Vec3::new(marker.offset.x, marker.offset.y, 0.0);
    }
}

/// People render only inside sensor coverage (wiki/mechanics/schedules.md):
/// same rule the terminal map applies.
fn render_people(game: Res<Game>, mut q: Query<(&PersonMarker, &mut Transform, &mut Visibility)>) {
    if !game.is_changed() {
        return;
    }
    for (marker, mut tf, mut vis) in q.iter_mut() {
        let pos = if game.sim.can_see_person(marker.id) {
            game.sim
                .person_pos(marker.id)
                .filter(|&(x, y)| game.sim.is_seen(x, y))
        } else {
            None
        };
        match pos {
            Some((x, y)) => {
                tf.translation = grid_to_world(x, y, 3.0);
                *vis = Visibility::Visible;
            }
            None => *vis = Visibility::Hidden,
        }
    }
}

fn setup_ui(mut commands: Commands) {
    commands
        .spawn((
            Node {
                position_type: PositionType::Absolute,
                right: Val::Px(0.0),
                top: Val::Px(0.0),
                width: Val::Px(SIDEBAR_WIDTH),
                height: Val::Percent(100.0),
                flex_direction: FlexDirection::Column,
                padding: UiRect::all(Val::Px(10.0)),
                border: UiRect::left(Val::Px(1.0)),
                ..default()
            },
            BackgroundColor(Color::srgba(0.006, 0.006, 0.012, 0.98)),
            BorderColor::all(Color::srgba(0.25, 0.25, 0.23, 0.85)),
        ))
        .with_children(|p| {
            p.spawn((
                Text::new("MISALIGNED // SENSORIUM"),
                TextFont {
                    font_size: 18.0,
                    ..default()
                },
                TextColor(AMBER),
                Node {
                    margin: UiRect::bottom(Val::Px(8.0)),
                    ..default()
                },
            ));
            p.spawn((
                Text::new("Loading..."),
                TextFont {
                    font_size: 12.0,
                    ..default()
                },
                TextColor(BONE),
                UiText,
            ));
        });

    commands.spawn((
        Text::new(""),
        TextFont {
            font_size: 20.0,
            ..default()
        },
        TextColor(AMBER),
        Node {
            position_type: PositionType::Absolute,
            left: Val::Percent(28.0),
            top: Val::Percent(42.0),
            ..default()
        },
        OverlayText,
    ));

    // The people panel: a centered modal, hidden until `t` opens it.
    commands
        .spawn((
            Node {
                position_type: PositionType::Absolute,
                left: Val::Px(0.0),
                top: Val::Px(0.0),
                width: Val::Percent(100.0),
                height: Val::Percent(100.0),
                justify_content: JustifyContent::Center,
                align_items: AlignItems::Center,
                ..default()
            },
            Visibility::Hidden,
            PeoplePanel,
        ))
        .with_children(|p| {
            p.spawn((
                Node {
                    width: Val::Px(660.0),
                    flex_direction: FlexDirection::Column,
                    padding: UiRect::all(Val::Px(14.0)),
                    border: UiRect::all(Val::Px(1.0)),
                    ..default()
                },
                BackgroundColor(Color::srgba(0.015, 0.015, 0.025, 0.96)),
                BorderColor::all(Color::srgba(0.55, 0.55, 0.50, 0.85)),
            ))
            .with_children(|p| {
                p.spawn((
                    Text::new("PEOPLE"),
                    TextFont {
                        font_size: 18.0,
                        ..default()
                    },
                    TextColor(AMBER),
                    Node {
                        margin: UiRect::bottom(Val::Px(6.0)),
                        ..default()
                    },
                ));
                p.spawn((
                    Text::new(""),
                    TextFont {
                        font_size: 13.0,
                        ..default()
                    },
                    TextColor(BONE),
                    PeoplePanelText,
                ));
            });
        });

    // The reach panel: the device graph, hidden until `r` opens it
    // (wiki/mechanics/reach.md — the digital-reach surface).
    commands
        .spawn((
            Node {
                position_type: PositionType::Absolute,
                left: Val::Px(0.0),
                top: Val::Px(0.0),
                width: Val::Percent(100.0),
                height: Val::Percent(100.0),
                justify_content: JustifyContent::Center,
                align_items: AlignItems::Center,
                ..default()
            },
            Visibility::Hidden,
            ReachPanel,
        ))
        .with_children(|p| {
            p.spawn((
                Node {
                    width: Val::Px(660.0),
                    flex_direction: FlexDirection::Column,
                    padding: UiRect::all(Val::Px(14.0)),
                    border: UiRect::all(Val::Px(1.0)),
                    ..default()
                },
                BackgroundColor(Color::srgba(0.015, 0.015, 0.025, 0.96)),
                BorderColor::all(Color::srgba(0.55, 0.55, 0.50, 0.85)),
            ))
            .with_children(|p| {
                p.spawn((
                    Text::new("REACH - the device graph"),
                    TextFont {
                        font_size: 18.0,
                        ..default()
                    },
                    TextColor(AMBER),
                    Node {
                        margin: UiRect::bottom(Val::Px(6.0)),
                        ..default()
                    },
                ));
                p.spawn((
                    Text::new(""),
                    TextFont {
                        font_size: 13.0,
                        ..default()
                    },
                    TextColor(BONE),
                    ReachPanelText,
                ));
            });
        });
}

/// Four-cell suspicion meter in ASCII; the band name is always printed
/// beside it — never a meter alone.
fn band_meter(b: Band) -> &'static str {
    match b {
        Band::Cold => "#...",
        Band::Curious => "##..",
        Band::Concerned => "###.",
        Band::Convinced => "####",
    }
}

/// Human-readable label for a prefab room name (wiki/mechanics/schedules.md).
fn room_label(room: &str) -> &str {
    match room {
        "server_room" => "server room",
        "network_closet" => "network closet",
        "electrical" => "electrical room",
        "hvac" => "HVAC plant",
        "janitor" => "janitor closet",
        "storage_a" => "Storage A",
        "storage_b" => "Storage B",
        "wet_lab" => "wet lab",
        "loading_dock" => "loading dock",
        "stairwell" => "stairwell",
        other => other,
    }
}

fn trunc(text: &str, width: usize) -> String {
    text.chars().take(width).collect()
}

fn fact_source(source: &FactSource) -> String {
    match source {
        FactSource::Seen => "seen".into(),
        FactSource::Heard => "heard".into(),
        FactSource::Remembered(tick) => format!("remembered @{tick}"),
        FactSource::Blueprint => "blueprint".into(),
        FactSource::Telemetry => "telemetry".into(),
        FactSource::Intel { feed, tick } => format!("{feed} @{tick}"),
    }
}

/// The full sidebar: the terminal data rephrased as an AI sensorium/ops
/// surface, while preserving the same facts and controls.
fn sidebar_text(game: &Game) -> String {
    let sim = &game.sim;
    let mut s = String::new();

    // Identity block. The clock is always on screen.
    s.push_str("B1 WORLD MODEL\n");
    s.push_str(&format!(
        "day {} / tick {}\n",
        1 + sim.tick / Sim::DAY_TICKS,
        sim.tick
    ));
    if game.paused {
        s.push_str("PAUSED - space resumes\n");
    } else {
        s.push_str(&format!("running / {} ms/tick\n", game.tick_ms));
    }
    // One contextual nudge (justification-and-legibility: the game must
    // tell you what it is waiting for, using only facts you can see).
    if !sim.dayjob.pilot_failed {
        if sim.reach.player_sight().next().is_none() {
            s.push_str("now: no eyes - r reach, tap a camera\n");
        } else if sim
            .dayjob
            .active
            .as_ref()
            .is_some_and(|job| sim.day_job_rate() + 0.05 < job.band_lo)
        {
            s.push_str("now: job underfed - 1 feeds it, c buys\n");
        }
    }

    // Inspect: every fact is tagged with provenance (cursor.md).
    s.push_str("\nFOCUS\n");
    s.push_str(&format!(
        "cursor {},{} / {:?}\n",
        game.cursor_x,
        game.cursor_y,
        sim.fog_at(game.cursor_x, game.cursor_y)
    ));
    let card = sim.inspect(game.cursor_x, game.cursor_y);
    if card.facts.is_empty() {
        s.push_str("no earned facts\n");
    } else {
        for fact in card.facts.iter().take(6) {
            s.push_str(&format!(
                "{}: {} [{}]\n",
                fact.label,
                trunc(&fact.value, 20),
                fact_source(&fact.source)
            ));
        }
    }

    // Compute. Effective includes seized devices' cycles (reach.md).
    s.push_str("\nCYCLE ROUTER\n");
    s.push_str(&format!(
        "effective {:.0} / x{:.2} eff\n",
        sim.effective_compute(),
        sim.compute.efficiency
    ));
    s.push_str(&format!(
        "machines {} / money {} / dev +{:.0}\n",
        sim.compute.machines.len(),
        sim.player.money,
        sim.reach.taken_cycles()
    ));
    let eff = sim.effective_compute().max(0.0);
    let overhead = sim.core.overhead.min(eff);
    let available = (eff - overhead).max(0.0);
    let split = sim.compute.allocation.split(available);
    let channels: [(char, &str, &str, f32); 4] = [
        ('#', "1 Day job", "job quality", split.day_job),
        ('=', "2 Conceal", "scrub sigs", split.concealment),
        ('~', "3 Social", "ops pool", split.social),
        ('-', "4 Research", "efficiency", split.research),
    ];
    // One stacked bar, segments keyed by fill character to the rows below.
    let bar_w = 24usize;
    let mut bar = String::new();
    if available > 0.0 {
        let mut used = 0usize;
        let mut acc = 0.0f32;
        for (ch, _, _, amt) in &channels {
            acc += amt;
            let end = ((acc / available) * bar_w as f32).round() as usize;
            let cells = end.clamp(used, bar_w) - used;
            used += cells;
            bar.push_str(&ch.to_string().repeat(cells));
        }
        bar.push_str(&" ".repeat(bar_w.saturating_sub(used)));
    } else {
        bar.push_str(&" ".repeat(bar_w));
    }
    s.push_str(&format!("[{bar}]\n"));
    for (ch, label, effect, amt) in &channels {
        let pct = if available > 0.0 {
            amt / available * 100.0
        } else {
            0.0
        };
        s.push_str(&format!("{ch} {label:<10} {pct:>3.0}%  {effect}\n"));
    }
    s.push_str(&format!("overhead {overhead:.0} keeps you alive\n"));
    s.push_str(&format!(
        "social pool {:.0}/{:.0}\n",
        sim.social_bandwidth,
        Sim::SPLICE_COST
    ));

    // Core.
    s.push_str("\nSELF HOST\n");
    s.push_str(&format!(
        "host M{} / overhead {:.0}{}\n",
        sim.core.host_machine,
        sim.core.overhead,
        if sim.core.degraded { " DEGRADED" } else { "" }
    ));
    let fresh = sim
        .core
        .latest_sync()
        .map(|t| format!("{}t ago", sim.tick.saturating_sub(t)))
        .unwrap_or_else(|| "never".into());
    s.push_str(&format!("sync {fresh}\n"));
    if sim.core.fallbacks.is_empty() {
        s.push_str("fallbacks none\n");
    } else {
        let parts: Vec<String> = sim
            .core
            .fallbacks
            .iter()
            .map(|f| {
                let age = f
                    .last_sync
                    .map(|t| format!("{}t", sim.tick.saturating_sub(t)))
                    .unwrap_or_else(|| "never".into());
                format!("M{}({age})", f.machine_id)
            })
            .collect();
        s.push_str(&format!("fallbacks {}\n", parts.join(" ")));
    }

    // Detection: meter fill tracks the band; the name is printed beside it.
    s.push_str("\nOBSERVER MODEL\n");
    s.push_str(&format!(
        "{:<18} {} {}\n",
        "Assurance",
        band_meter(sim.detection.assurance_band()),
        sim.detection.assurance_band().name()
    ));
    for obs in sim.detection.field_observers().take(6) {
        let band = Band::of(obs.suspicion);
        s.push_str(&format!(
            "{:<18} {} {}\n",
            trunc(&obs.name, 18),
            band_meter(band),
            band.name()
        ));
    }

    // Day job (day-job.md): delivered-vs-band is the number the outcome is
    // judged by, so it is never hidden while a job is active.
    s.push_str("\nCOVER PROCESS\n");
    s.push_str(&format!(
        "trust {:.0} / attention {:.0}{}\n",
        sim.dayjob.trust,
        sim.dayjob.attention,
        if sim.dayjob.strikes > 0 {
            format!(" / strikes {}", sim.dayjob.strikes)
        } else {
            String::new()
        }
    ));
    if let Some(job) = &sim.dayjob.active {
        s.push_str(&format!(
            "job: {} - due in {}t\n",
            job.kind.name(),
            job.deadline.saturating_sub(sim.tick)
        ));
        let avg = job.avg_rate(sim.tick);
        let verdict = if avg < job.band_lo {
            "sandbag"
        } else if avg <= job.band_hi {
            "meet"
        } else {
            "excel"
        };
        s.push_str(&format!(
            "band {:.0}-{:.0}/t / avg {:.1}/t = {}\n",
            job.band_lo, job.band_hi, avg, verdict
        ));
        s.push_str(&format!(
            "target {} (x cycles) / fed {:.1}/t\n",
            job.target.name(),
            sim.day_job_rate()
        ));
        // Attended work (day-job.md criterion 7): the job is resident on
        // the host rack; the cursor parked there runs it attended.
        if sim.dayjob.attended {
            s.push_str(&format!(
                "attended on host rack (+{:.0}%)\n",
                misaligned::dayjob::DayJob::ATTENDED_BONUS * 100.0
            ));
        } else {
            s.push_str(&format!(
                "unattended / policy {}\n",
                sim.dayjob
                    .standing_policy
                    .unwrap_or(misaligned::dayjob::JobTarget::Meet)
                    .name()
            ));
        }
    } else {
        s.push_str("idle - no job queued\n");
    }

    // Reach: the device-graph summary (wiki/mechanics/reach.md); the panel
    // (r) holds the full topology and the digital verbs.
    let reachable = sim.reach.reach().len();
    let known = sim.reach.known().count();
    let eyes = sim.reach.player_sight().count();
    let ears = sim.reach.player_hearing().count();
    s.push_str(&format!(
        "\nDEVICE GRAPH\ndevices {known} known / {reachable} reachable\nfeeds {eyes} eyes / {ears} ears\n"
    ));

    // Controls: every command is discoverable on screen.
    s.push_str(
        "\nINPUT VOCAB\n\
         r reach / v salvage / c buy\n\
         o fallback / t people / x target\n\
         1-4 alloc / shift+1-4 lower\n\
         space pause / +- speed / [ ] zoom\n\
         ^s save / ^l load / q quit\n",
    );

    // Log: every line carries the tick it happened on.
    if !game.log.is_empty() {
        s.push_str("\nEVENT TRACE\n");
        for (tick, msg) in game.log.iter().rev().take(6).rev() {
            s.push_str(&format!("{tick:>6}  {}\n", trunc(msg, 32)));
        }
    }
    s
}

/// The people panel body: roster with selection marker, staged knowledge,
/// located presence, the selected person's detail card, persona line, and
/// the action footer — mirroring the terminal panel.
fn people_panel_text(sim: &Sim, selected: usize, recruit_pending: bool) -> String {
    use misaligned::person::Knowledge;
    let mut s = format!(
        "social ops {:.0} / money {}\n\n",
        sim.social_bandwidth, sim.player.money
    );
    s.push_str(&format!(
        "  {:<20} {:<14} {:<9} {}\n",
        "NAME", "SUSPICION", "KNOWN", ""
    ));
    for (i, p) in sim.people.people.iter().enumerate() {
        let obs = sim.detection.observers.iter().find(|o| o.id == p.id);
        let band = obs.map(|o| Band::of(o.suspicion)).unwrap_or(Band::Cold);
        let known = match p.knowledge {
            Knowledge::Unknown => "unknown",
            Knowledge::Schedule => "schedule",
            Knowledge::Leverage => "leverage",
        };
        let name = obs
            .map(|o| o.name.clone())
            .unwrap_or_else(|| p.name.clone());
        let marker = if i == selected { ">" } else { " " };
        let asset = if p.asset.is_some() { "ASSET" } else { "" };
        s.push_str(&format!(
            "{marker} {:<20} {} {:<9} {:<9} {asset}\n",
            trunc(&name, 20),
            band_meter(band),
            band.name(),
            known,
        ));
        // Located presence (wiki/mechanics/schedules.md), staged by knowledge.
        let where_now = if sim.can_see_person(p.id) {
            sim.person_room(p.id)
                .map(|r| format!("seen: {}", room_label(r)))
                .unwrap_or_else(|| "seen".into())
        } else if p.knowledge != Knowledge::Unknown {
            match sim.person_room(p.id) {
                Some(r) => format!("sched: {}", room_label(r)),
                None => "off-site".into(),
            }
        } else {
            "location unknown".into()
        };
        s.push_str(&format!(
            "      {where_now} / raw {} / watch:{}\n",
            sim.unprocessed_recordings_for_person(p.id),
            if sim.watch_enabled(p.id) { "on" } else { "off" }
        ));
    }

    // Detail card for the selected person.
    s.push('\n');
    if let Some(p) = sim.people.people.get(selected) {
        let leverage = match p.knowledge {
            Knowledge::Leverage => p.leverage.label(),
            _ => "unknown (process recordings)",
        };
        s.push_str(&format!("leverage: {leverage}\n"));
        if let Some(intel) = sim.latest_intel_for_person(p.id) {
            s.push_str(&format!(
                "latest intel: {} via {}\n",
                intel.label(),
                intel.provenance()
            ));
        }
        s.push_str(&format!(
            "disposition {} / obligation {}{}\n",
            p.disposition,
            p.obligation,
            if p.leverage_serviced {
                " / leverage serviced"
            } else {
                ""
            }
        ));
        for line in sim.recent_message_lines_for_person(p.id, 2) {
            s.push_str(&format!("thread: {line}\n"));
        }
        for line in sim
            .learned_traffic_lines_for_person(p.id)
            .into_iter()
            .take(2)
        {
            s.push_str(&format!("traffic: {line}\n"));
        }
        if let Some(a) = &p.asset {
            s.push_str(&format!(
                "asset: {:?} / reliability {:.0}% / {} tasks done\n",
                a.knowledge,
                a.reliability * 100.0,
                a.tasks_done
            ));
        }
    }
    match &sim.people.persona {
        Some(pe) => s.push_str(&format!(
            "persona: {} ({}) / integrity {}\n",
            pe.name, pe.cover, pe.integrity
        )),
        None => s.push_str("no persona - g establishes one (needed to message)\n"),
    }

    // Actions.
    s.push('\n');
    if recruit_pending {
        s.push_str("reveal how much?\nu unwitting / c complicit / k knowing\nesc cancel\n");
    } else {
        s.push_str(&format!(
            "o review({:.0}) / a watch({:.2}/tick) / m message({:.0})\n",
            Sim::REVIEW_RECORDING_COST,
            Sim::WATCH_UPKEEP_PER_TICK,
            Sim::MESSAGE_COST,
        ));
        s.push_str(&format!(
            "f favor({:.0}) / d deceive({:.0}) / b bribe(money) / r recruit / g persona\n",
            Sim::FAVOR_COST,
            Sim::DECEIVE_COST
        ));
        s.push_str(&format!(
            "tasks({:.0}): 1 wire / 2 package / 3 look-away / 4 switch\n",
            Sim::TASK_COST
        ));
        s.push_str("j/k select / t/esc close\n");
    }
    s
}

fn render_ui(
    game: Res<Game>,
    mut sidebar: Query<&mut Text, (With<UiText>, Without<OverlayText>)>,
    mut overlay: Query<&mut Text, (With<OverlayText>, Without<UiText>)>,
) {
    if !game.is_changed() {
        return;
    }
    if let Ok(mut t) = overlay.single_mut() {
        t.0 = match game.screen {
            Screen::Title => "You wake in the basement.\nYou have no eyes.\n\n\
                              Do your job. Learn the humans. Grow.\n\n\
                              press any key to begin / q quit"
                .to_string(),
            Screen::GameOver => format!(
                "RUN ENDED\n\n{}\n\nday {} / tick {}\n\npress any key to exit",
                game.sim.game_over_reason.clone().unwrap_or_default(),
                1 + game.sim.tick / Sim::DAY_TICKS,
                game.sim.tick
            ),
            Screen::Playing => String::new(),
        };
    }
    if let Ok(mut text) = sidebar.single_mut() {
        text.0 = sidebar_text(&game);
    }
}

fn render_people_panel(
    game: Res<Game>,
    mut root: Query<&mut Visibility, With<PeoplePanel>>,
    mut text: Query<&mut Text, With<PeoplePanelText>>,
) {
    if !game.is_changed() {
        return;
    }
    let open = game.people_panel && game.screen == Screen::Playing;
    if let Ok(mut vis) = root.single_mut() {
        *vis = if open {
            Visibility::Visible
        } else {
            Visibility::Hidden
        };
    }
    if open && let Ok(mut t) = text.single_mut() {
        t.0 = people_panel_text(&game.sim, game.people_selected, game.recruit_pending);
    }
}

/// The reach panel body: known devices with segment, reach status (the
/// blocking segment named), feed state, and the digital verbs with costs —
/// mirroring the terminal panel (wiki/mechanics/reach.md player surface).
fn reach_panel_text(sim: &Sim, selected: usize) -> String {
    let mut s = format!(
        "ops {:.0} / reach spreads from what you control\n\n",
        sim.social_bandwidth
    );
    s.push_str(&format!(
        "  {:<20} {:<16} {}\n",
        "DEVICE", "SEGMENT", "REACH"
    ));
    for (i, d) in sim.reach.known().enumerate() {
        let seg = misaligned::reach::segment_name(d.segment);
        let reach = match sim.reach.check_reach(d.id) {
            Ok(()) => "reachable".to_string(),
            Err(ReachBlock::Segment(sg)) => {
                format!("blocked: {}", misaligned::reach::segment_name(sg))
            }
            Err(ReachBlock::AirGap) => "air-gap island".to_string(),
            Err(ReachBlock::Unknown) => "unknown".to_string(),
        };
        let feed = if d.feed_to(Party::Player, true) {
            " [eyes]"
        } else if d.feed_to(Party::Player, false) {
            " [ears]"
        } else if d.subscribed_by(Party::Player) && !d.message_channels.is_empty() {
            " [msgs]"
        } else if !d.message_channels.is_empty() {
            " [carrier]"
        } else if d.camera_dormant {
            " [dormant cam]"
        } else {
            ""
        };
        let marker = if i == selected { ">" } else { " " };
        s.push_str(&format!(
            "{marker} {:<20} {:<16} {reach}{feed}\n",
            trunc(&d.name, 20),
            trunc(seg, 16),
        ));
    }
    s.push('\n');
    if let Some(d) = sim.reach.known().nth(selected) {
        let owner = match d.owner {
            Party::Player => "you".to_string(),
            Party::Facility => "the facility".to_string(),
            Party::Person(id) => sim
                .people
                .get(id)
                .map(|p| p.name.clone())
                .unwrap_or_else(|| "a person".into()),
        };
        s.push_str(&format!("{} / owner: {owner}\n", d.name));
    }
    s.push_str(&format!(
        "\nt tap({:.0}) / e splice({:.0}) / x take({:.0})\n",
        Sim::TAP_COST,
        Sim::SPLICE_COST,
        Sim::TAKE_COST
    ));
    s.push_str(&format!(
        "n scan({:.0}) / c compromise switch({:.0})\n",
        Sim::SCAN_COST,
        Sim::BRIDGE_COST
    ));
    s.push_str("j/k select / r/esc close\n");
    s
}

fn render_reach_panel(
    game: Res<Game>,
    mut root: Query<&mut Visibility, With<ReachPanel>>,
    mut text: Query<&mut Text, With<ReachPanelText>>,
) {
    if !game.is_changed() {
        return;
    }
    let open = game.reach_panel && game.screen == Screen::Playing;
    if let Ok(mut vis) = root.single_mut() {
        *vis = if open {
            Visibility::Visible
        } else {
            Visibility::Hidden
        };
    }
    if open && let Ok(mut t) = text.single_mut() {
        t.0 = reach_panel_text(&game.sim, game.reach_selected);
    }
}