//! Procedural asset tester — orbit a flat-material mesh without booting the game.
//!
//! ```bash
//! cargo run --features bevy_ui --bin misaligned-assets
//! ```
//!
//! Controls: drag orbit, scroll zoom, 1-5 rack state, Q/W/E claim style,
//! L lineup view (all five states side by side), Esc quit.

mod palette;
mod rack;

use bevy::input::mouse::{AccumulatedMouseMotion, AccumulatedMouseScroll};
use bevy::prelude::*;
use bevy::render::view::screenshot::{Screenshot, save_to_disk};
use bevy::window::{CursorGrabMode, CursorOptions, WindowResolution};

use palette::{GUNMETAL, NEAR_BLACK, PORCELAIN};
use rack::{Blink, ClaimStyle, RackRoot, RackState, spawn_server_rack};

/// Single asset on the pedestal, or all five states side by side.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Resource)]
enum ViewMode {
    #[default]
    Single,
    Lineup,
}

/// Dev screenshot harness (`MISALIGNED_SHOT=<kind>`, path via
/// `MISALIGNED_SHOT_PATH`): apply the staged scene, settle, save one
/// PNG, exit. Kinds: `dead|foreign|idle|busy|core` optionally suffixed
/// `_ladder|_ring|_wash`, `lineup[_<style>]` for the five-state row,
/// or `splash` for a HUD-less white-room hero (site splash). Legacy
/// `rack|powered` map to idle. Not a player surface — agents capture
/// review shots without a human at the keyboard.
#[derive(Resource)]
struct ShotHarness {
    path: String,
    frames: u32,
    taken: bool,
    /// White-room hero: hide HUD, porcelain clear color, vast floor.
    splash: bool,
}

fn scene_from_shot(kind: &str) -> (ViewMode, RackState, ClaimStyle, bool) {
    if kind == "splash" {
        return (ViewMode::Single, RackState::Idle, ClaimStyle::Ring, true);
    }
    let (head, style_tag) = match kind.split_once('_') {
        Some((h, s)) => (h, Some(s)),
        None => (kind, None),
    };
    let style = match style_tag {
        Some("ring") => ClaimStyle::Ring,
        Some("wash") => ClaimStyle::Wash,
        _ => ClaimStyle::Ladder,
    };
    let (mode, state) = match head {
        "lineup" => (ViewMode::Lineup, RackState::Idle),
        "dead" => (ViewMode::Single, RackState::Dead),
        "foreign" => (ViewMode::Single, RackState::Foreign),
        "busy" => (ViewMode::Single, RackState::Busy),
        "core" => (ViewMode::Single, RackState::Core),
        // `idle` plus legacy `rack`/`powered` and anything unrecognized.
        _ => (ViewMode::Single, RackState::Idle),
    };
    (mode, state, style, false)
}

fn main() {
    // Dev screenshot harness: stage a scene and capture one PNG.
    // Never active in normal interactive use.
    let harness = std::env::var("MISALIGNED_SHOT").ok().map(|kind| {
        let path = std::env::var("MISALIGNED_SHOT_PATH")
            .unwrap_or_else(|_| format!("misaligned_shot_{kind}.png"));
        let (mode, state, style, splash) = scene_from_shot(&kind);
        (
            (mode, state, style),
            ShotHarness {
                path,
                frames: 150,
                taken: false,
                splash,
            },
        )
    });
    let splash = harness.as_ref().map(|(_, h)| h.splash).unwrap_or(false);
    let (initial_mode, initial_state, initial_style) = harness
        .as_ref()
        .map(|(scene, _)| *scene)
        .unwrap_or((ViewMode::Single, RackState::Idle, ClaimStyle::Ladder));

    let clear = if splash {
        // Bone / porcelain expanse — sterile empty room for the site hero.
        Color::srgb(0.92, 0.915, 0.90)
    } else {
        NEAR_BLACK
    };
    let ambient = if splash {
        GlobalAmbientLight {
            color: Color::srgb(0.95, 0.95, 0.94),
            brightness: 95.0,
            ..default()
        }
    } else {
        GlobalAmbientLight {
            color: Color::srgb(0.48, 0.55, 0.70),
            brightness: 28.0,
            ..default()
        }
    };

    let mut app = App::new();
    app.add_plugins(DefaultPlugins.set(WindowPlugin {
        primary_window: Some(Window {
            title: "Misaligned — asset tester".into(),
            resolution: WindowResolution::new(
                if splash { 1400 } else { 1100 },
                if splash { 900 } else { 720 },
            ),
            ..default()
        }),
        ..default()
    }))
    .insert_resource(ClearColor(clear))
    .insert_resource(ambient)
    .insert_resource(initial_state)
    .insert_resource(initial_style)
    .insert_resource(initial_mode)
    .insert_resource(if splash {
        Orbit {
            // Frontal three-quarter, pulled back so the room reads as expanse.
            yaw: 0.55,
            pitch: 0.18,
            distance: 6.2,
            target: Vec3::new(0.0, 0.85, 0.0),
        }
    } else {
        orbit_for(initial_mode)
    })
    .add_systems(Startup, setup)
    .add_systems(
        Update,
        (
            handle_quit,
            handle_state_keys,
            reframe_on_mode_change,
            orbit_camera,
            rebuild_scene,
            blink_emissives,
            update_hud,
            shot_harness_system,
        ),
    );
    if let Some((_, harness)) = harness {
        app.insert_resource(harness);
    }
    app.run();
}

#[derive(Resource)]
struct Orbit {
    yaw: f32,
    pitch: f32,
    distance: f32,
    target: Vec3,
}

fn orbit_for(mode: ViewMode) -> Orbit {
    match mode {
        // Slightly more frontal so the open bay cavity reads.
        ViewMode::Single => Orbit {
            yaw: 0.42,
            pitch: 0.28,
            distance: 3.8,
            target: Vec3::new(0.0, 0.95, 0.0),
        },
        ViewMode::Lineup => Orbit {
            yaw: 0.14,
            pitch: 0.20,
            distance: 7.4,
            target: Vec3::new(0.0, 0.95, 0.0),
        },
    }
}

#[derive(Component)]
struct HudText;

#[derive(Component)]
struct PedestalRoot;

/// Spacing between rack centers in the lineup view.
const LINEUP_PITCH: f32 = 1.35;

fn setup(mut commands: Commands, orbit: Res<Orbit>, harness: Option<Res<ShotHarness>>) {
    let splash = harness.as_ref().is_some_and(|h| h.splash);

    // Camera (the scene itself is spawned by rebuild_scene on frame 1).
    let eye = orbit_eye(&orbit);
    commands.spawn((
        Camera3d::default(),
        Transform::from_translation(eye).looking_at(orbit.target, Vec3::Y),
    ));

    if splash {
        // Soft clinical wash — LEDs still own amber; room stays bone-white.
        commands.spawn((
            PointLight {
                color: Color::srgb(0.95, 0.96, 0.98),
                intensity: 2_400_000.0,
                range: 40.0,
                shadows_enabled: true,
                ..default()
            },
            Transform::from_xyz(3.5, 7.0, 4.0),
        ));
        commands.spawn((
            PointLight {
                color: Color::srgb(0.90, 0.91, 0.93),
                intensity: 900_000.0,
                range: 30.0,
                shadows_enabled: false,
                ..default()
            },
            Transform::from_xyz(-4.0, 5.0, -2.5),
        ));
        // No HUD on splash captures.
        return;
    }

    // Lights: cool clinical key only — machine presence must be entirely
    // LED/strip-owned, so no warm scene light anywhere.
    commands.spawn((
        PointLight {
            color: Color::srgb(0.72, 0.80, 0.95),
            intensity: 1_100_000.0,
            range: 16.0,
            shadows_enabled: true,
            ..default()
        },
        Transform::from_xyz(2.2, 4.2, 2.8),
    ));
    commands.spawn((
        PointLight {
            color: Color::srgb(0.55, 0.62, 0.78),
            intensity: 420_000.0,
            range: 12.0,
            shadows_enabled: false,
            ..default()
        },
        Transform::from_xyz(-1.8, 3.0, -1.2),
    ));

    // HUD (text filled in by update_hud on frame 1).
    commands.spawn((
        Text::new(String::new()),
        TextFont {
            font_size: 18.0,
            ..default()
        },
        TextColor(Color::srgb(0.86, 0.85, 0.82)),
        Node {
            position_type: PositionType::Absolute,
            top: Val::Px(16.0),
            left: Val::Px(18.0),
            ..default()
        },
        HudText,
    ));
}

fn hud_string(mode: ViewMode, state: RackState, style: ClaimStyle) -> String {
    let line2 = match mode {
        ViewMode::Single => format!(
            "state: {}  (1 dead  2 foreign  3 idle  4 busy  5 core)",
            state.label()
        ),
        ViewMode::Lineup => {
            "lineup: dead | foreign | idle | busy | core  (left to right)".to_string()
        }
    };
    format!(
        "asset: server_rack\n{line2}\nclaim: {}  (Q ladder  W ring  E wash)   L toggles lineup\ndrag orbit - scroll zoom - Esc quit",
        style.label()
    )
}

fn orbit_eye(orbit: &Orbit) -> Vec3 {
    let cp = orbit.pitch.cos();
    let sp = orbit.pitch.sin();
    let cy = orbit.yaw.cos();
    let sy = orbit.yaw.sin();
    orbit.target
        + Vec3::new(
            orbit.distance * cp * sy,
            orbit.distance * sp,
            orbit.distance * cp * cy,
        )
}

fn handle_quit(kb: Res<ButtonInput<KeyCode>>, mut exit: MessageWriter<AppExit>) {
    if kb.just_pressed(KeyCode::Escape) {
        exit.write(AppExit::Success);
    }
}

fn handle_state_keys(
    kb: Res<ButtonInput<KeyCode>>,
    mut state: ResMut<RackState>,
    mut style: ResMut<ClaimStyle>,
    mut mode: ResMut<ViewMode>,
) {
    for (key, n) in [
        (KeyCode::Digit1, 1u8),
        (KeyCode::Digit2, 2),
        (KeyCode::Digit3, 3),
        (KeyCode::Digit4, 4),
        (KeyCode::Digit5, 5),
        (KeyCode::Numpad1, 1),
        (KeyCode::Numpad2, 2),
        (KeyCode::Numpad3, 3),
        (KeyCode::Numpad4, 4),
        (KeyCode::Numpad5, 5),
    ] {
        if kb.just_pressed(key)
            && let Some(next) = RackState::from_digit(n)
            && *state != next
        {
            *state = next;
        }
    }
    for (key, next) in [
        (KeyCode::KeyQ, ClaimStyle::Ladder),
        (KeyCode::KeyW, ClaimStyle::Ring),
        (KeyCode::KeyE, ClaimStyle::Wash),
    ] {
        if kb.just_pressed(key) && *style != next {
            *style = next;
        }
    }
    if kb.just_pressed(KeyCode::KeyL) {
        *mode = match *mode {
            ViewMode::Single => ViewMode::Lineup,
            ViewMode::Lineup => ViewMode::Single,
        };
    }
}

fn reframe_on_mode_change(mode: Res<ViewMode>, mut orbit: ResMut<Orbit>) {
    if mode.is_changed() && !mode.is_added() {
        *orbit = orbit_for(*mode);
    }
}

fn orbit_camera(
    buttons: Res<ButtonInput<MouseButton>>,
    motion: Res<AccumulatedMouseMotion>,
    scroll: Res<AccumulatedMouseScroll>,
    mut orbit: ResMut<Orbit>,
    mut q: Query<&mut Transform, With<Camera3d>>,
    mut windows: Query<&mut CursorOptions>,
) {
    if buttons.pressed(MouseButton::Left) || buttons.pressed(MouseButton::Right) {
        let delta = motion.delta;
        orbit.yaw -= delta.x * 0.005;
        orbit.pitch = (orbit.pitch + delta.y * 0.005).clamp(-1.2, 1.35);
        if let Ok(mut opts) = windows.single_mut() {
            opts.grab_mode = CursorGrabMode::Confined;
        }
    } else if let Ok(mut opts) = windows.single_mut() {
        opts.grab_mode = CursorGrabMode::None;
    }

    let scroll_y = scroll.delta.y;
    if scroll_y.abs() > 0.0 {
        orbit.distance = (orbit.distance * (1.0 - scroll_y * 0.08)).clamp(1.6, 14.0);
    }

    let eye = orbit_eye(&orbit);
    if let Ok(mut tf) = q.single_mut() {
        *tf = Transform::from_translation(eye).looking_at(orbit.target, Vec3::Y);
    }
}

#[allow(clippy::too_many_arguments)]
fn rebuild_scene(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
    state: Res<RackState>,
    style: Res<ClaimStyle>,
    mode: Res<ViewMode>,
    racks: Query<Entity, With<RackRoot>>,
    pedestals: Query<Entity, With<PedestalRoot>>,
    harness: Option<Res<ShotHarness>>,
) {
    if !(state.is_changed() || style.is_changed() || mode.is_changed()) {
        return;
    }
    for e in racks.iter().chain(pedestals.iter()) {
        commands.entity(e).despawn();
    }

    let splash = harness.as_ref().is_some_and(|h| h.splash);

    // Pedestal / floor sized to the view. Splash: vast porcelain slab, no
    // gunmetal plate — one rack in an empty room that goes on forever.
    let (floor_w, floor_d, plate_w) = if splash {
        (48.0, 48.0, 0.0)
    } else {
        match *mode {
            ViewMode::Single => (2.4, 2.4, 1.1),
            ViewMode::Lineup => (LINEUP_PITCH * 5.6, 2.4, LINEUP_PITCH * 5.0),
        }
    };
    let pedestal = commands
        .spawn((
            PedestalRoot,
            Transform::default(),
            Visibility::default(),
            Name::new("pedestal"),
        ))
        .id();
    let floor_mat = materials.add(StandardMaterial {
        base_color: if splash {
            Color::srgb(0.90, 0.895, 0.88)
        } else {
            PORCELAIN
        },
        perceptual_roughness: 0.92,
        metallic: 0.02,
        ..default()
    });
    commands.spawn((
        Mesh3d(meshes.add(Cuboid::new(floor_w, 0.08, floor_d))),
        MeshMaterial3d(floor_mat),
        Transform::from_xyz(0.0, -0.04, 0.0),
        ChildOf(pedestal),
    ));
    if plate_w > 0.0 {
        let ring_mat = materials.add(StandardMaterial {
            base_color: GUNMETAL,
            perceptual_roughness: 0.65,
            metallic: 0.4,
            ..default()
        });
        commands.spawn((
            Mesh3d(meshes.add(Cuboid::new(plate_w, 0.06, 1.1))),
            MeshMaterial3d(ring_mat),
            Transform::from_xyz(0.0, 0.02, 0.0),
            ChildOf(pedestal),
        ));
    }

    match *mode {
        ViewMode::Single => {
            spawn_server_rack(
                &mut commands,
                &mut meshes,
                &mut materials,
                *state,
                *style,
                Vec3::ZERO,
                Some(pedestal),
            );
        }
        ViewMode::Lineup => {
            let n = RackState::ALL.len();
            for (i, s) in RackState::ALL.into_iter().enumerate() {
                let x = (i as f32 - (n as f32 - 1.0) * 0.5) * LINEUP_PITCH;
                spawn_server_rack(
                    &mut commands,
                    &mut meshes,
                    &mut materials,
                    s,
                    *style,
                    Vec3::new(x, 0.0, 0.0),
                    Some(pedestal),
                );
            }
        }
    }
}

/// Pulse busy machines' emissives so task activity reads as motion.
fn blink_emissives(
    time: Res<Time>,
    mut materials: ResMut<Assets<StandardMaterial>>,
    q: Query<(&Blink, &MeshMaterial3d<StandardMaterial>)>,
) {
    let t = time.elapsed_secs();
    for (blink, mat) in &q {
        if let Some(m) = materials.get_mut(&mat.0) {
            let k = 0.55 + 0.45 * (t * 3.5 + blink.phase).sin();
            m.emissive = blink.base * k;
        }
    }
}

fn update_hud(
    state: Res<RackState>,
    style: Res<ClaimStyle>,
    mode: Res<ViewMode>,
    mut q: Query<&mut Text, With<HudText>>,
) {
    if !(state.is_changed() || style.is_changed() || mode.is_changed()) {
        return;
    }
    if let Ok(mut text) = q.single_mut() {
        *text = Text::new(hud_string(*mode, *state, *style));
    }
}

/// Countdown, capture, countdown, exit: gives meshes/materials and the
/// first present frames time to settle before the PNG is taken.
fn shot_harness_system(
    mut commands: Commands,
    harness: Option<ResMut<ShotHarness>>,
    mut exit: MessageWriter<AppExit>,
) {
    let Some(mut h) = harness else {
        return;
    };
    if h.frames > 0 {
        h.frames -= 1;
        return;
    }
    if !h.taken {
        h.taken = true;
        h.frames = 90;
        let path = std::path::PathBuf::from(&h.path);
        commands
            .spawn(Screenshot::primary_window())
            .observe(save_to_disk(path));
    } else {
        exit.write(AppExit::Success);
    }
}