app.rs

use std::f32::consts::{FRAC_PI_2, TAU};
use std::path::PathBuf;
use std::time::{Duration, Instant};

use eframe::egui::{self, vec2, Align2, FontId, Margin, RichText, Sense, Stroke};

use crate::ai::{self, Provider, SharedAi, Status, PROVIDERS};
use crate::camera::{self, CamStatus, Camera};
use crate::eye::{self, EyeState};
use crate::files::{FileAction, FileBrowser};
use crate::scan::{ScanKind, ScanStatus, Scanner};
use crate::globe;
use crate::keyboard::Keyboard;
use crate::sound::{Rng, Sfx, Sound};
use crate::stats::{self, NetStatus, Shared, SharedNet, Snapshot};
use crate::terminal::{self, Terminal};
use crate::theme::Theme;
use crate::widgets::{self as w, fmt_bytes, fmt_duration, truncate};

const SIDE_WIDTH: f32 = 310.0;

/// Purely cosmetic boot sequence.
const BOOT_LOG: &[&str] = &[
    "QUANTUM CORE ............... SYNCHRONIZED",
    "ENTROPY POOL ............... 4096 QBITS",
    "NEURAL INTERFACE ........... CALIBRATED",
    "BIOMETRIC SIGNATURE ........ VERIFIED",
    "HOLO-RENDER PIPELINE ....... ONLINE",
    "MESH UPLINK ................ 7 RELAYS",
    "ENCRYPTION ................. POST-QUANTUM / KYBER-1024",
    "INTRUSION SHIELD ........... ARMED",
    "ORBITAL NODE MAP ........... LOCKED",
    "SYSTEM PROBES .............. ATTACHED",
    "DAEMON CORE ................ AWAKENED",
    "SHELL DAEMON ............... SPAWNED",
    "ALL SUBSYSTEMS ............. NOMINAL",
];
/// Boot lines revealed per second.
const BOOT_SPEED: f32 = 3.0;
/// Extra ticks (at BOOT_SPEED) the welcome screen stays up.
const BOOT_HOLD: usize = 8;
/// Boot seconds over which the eye opens.
const EYE_OPEN: (f32, f32) = (0.6, 1.9);
/// Boot seconds at which the eye blinks.
const BLINKS: [f32; 2] = [3.3, 3.85];

pub struct DaemonApp {
    theme: Theme,
    stats: Shared,
    net: SharedNet,
    term: Option<Terminal>,
    term_err: Option<String>,
    files: FileBrowser,
    sound: Sound,
    rng: Rng,
    last_key_sound: Instant,
    next_chatter: f64,
    boot_start: Instant,
    boot_lines_played: usize,
    /// Bit set of boot sound cues already played.
    boot_cues: u8,
    keyboard: Keyboard,
    show_keyboard: bool,
    /// Time the deep-scan overlay was opened, while it is open.
    scan_opened: Option<f64>,
    /// Multi-model AI analysis panel (F7).
    ai: SharedAi,
    show_ai: bool,
    /// Provider whose reply the AI panel shows.
    ai_provider: Provider,
    /// Camera feed panel (F6). The camera is only open while the panel is.
    camera: Camera,
    show_camera: bool,
    cam_texture: Option<egui::TextureHandle>,
    /// `seq` of the frame currently in `cam_texture`.
    cam_seq: u64,
    cam_mirror: bool,
    cam_holo: bool,
    /// Result of the last snapshot: (message, is_error).
    cam_note: Option<(String, bool)>,
    home: PathBuf,
    /// Malware scan panel (F5). Scans keep running when the panel is closed.
    scanner: Scanner,
    show_threats: bool,
    booted: bool,
    ctx: egui::Context,
}

fn home_dir() -> PathBuf {
    std::env::var_os(if cfg!(windows) { "USERPROFILE" } else { "HOME" })
        .map(PathBuf::from)
        .or_else(|| std::env::current_dir().ok())
        .unwrap_or_else(|| PathBuf::from("."))
}

fn apply_style(ctx: &egui::Context, t: &Theme) {
    let mut style = (*ctx.style()).clone();
    let v = &mut style.visuals;
    *v = egui::Visuals::dark();
    v.override_text_color = Some(t.text);
    v.panel_fill = t.bg;
    v.window_fill = t.bg;
    v.extreme_bg_color = t.bg;
    v.faint_bg_color = t.alpha(12);
    v.selection.bg_fill = t.alpha(70);
    v.widgets.noninteractive.bg_stroke = Stroke::new(1.0_f32, t.alpha(60));
    style.override_font_id = Some(FontId::monospace(12.0));
    style.spacing.item_spacing = vec2(6.0, 3.0);
    ctx.set_style(style);
}

/// Transparent outer frame for a panel: leaves a gap around the glass panel inside it.
fn gap_frame() -> egui::Frame {
    egui::Frame::none().inner_margin(Margin::same(5.0))
}

/// Floating translucent "glass" panel that fills the space it is given.
fn glass<R>(ui: &mut egui::Ui, t: &Theme, add: impl FnOnce(&mut egui::Ui) -> R) -> R {
    egui::Frame::none()
        .fill(t.panel)
        .rounding(10.0)
        .inner_margin(Margin::same(12.0))
        .stroke(Stroke::new(1.0_f32, t.alpha(40)))
        .show(ui, |ui| {
            ui.set_min_size(ui.available_size());
            w::corners(ui.ctx(), ui.max_rect().expand(12.0), t.accent_alpha(170));
            add(ui)
        })
        .inner
}

fn internet_label(net: &NetStatus) -> &'static str {
    match net.online {
        Some(true) => "ONLINE",
        Some(false) => "OFFLINE",
        None => "CHECKING…",
    }
}

/// Stopwatch time: "03:12", or "1:03:12" past an hour.
fn clock(secs: u64) -> String {
    let (h, m, s) = (secs / 3600, secs % 3600 / 60, secs % 60);
    if h > 0 {
        format!("{h}:{m:02}:{s:02}")
    } else {
        format!("{m:02}:{s:02}")
    }
}

/// Something the user can trigger with a function key or by clicking a top-bar pill.
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
enum Action {
    Threats,
    Camera,
    Ai,
    DeepScan,
    Sound,
}

fn key_pressed(events: &[egui::Event], key: egui::Key) -> bool {
    events.iter().any(|e| matches!(e, egui::Event::Key { key: k, pressed: true, .. } if *k == key))
}

impl DaemonApp {
    pub fn new(cc: &eframe::CreationContext<'_>, theme: Theme, muted: bool) -> Self {
        let ctx = cc.egui_ctx.clone();
        apply_style(&ctx, &theme);
        // `with_maximized` on the builder is not always honored on Windows; ask again at runtime.
        ctx.send_viewport_cmd(egui::ViewportCommand::Maximized(true));
        let start_dir = home_dir();
        let (term, term_err) = match Terminal::new(ctx.clone(), &start_dir) {
            Ok(t) => (Some(t), None),
            Err(e) => (None, Some(e)),
        };
        let seed = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .map(|d| d.as_nanos() as u64)
            .unwrap_or(1)
            | 1;
        Self {
            theme,
            stats: stats::spawn(ctx.clone()),
            net: stats::spawn_net_probe(ctx.clone()),
            term,
            term_err,
            files: FileBrowser::new(start_dir.clone()),
            sound: Sound::new(muted),
            rng: Rng(seed),
            last_key_sound: Instant::now(),
            next_chatter: 8.0,
            boot_start: Instant::now(),
            boot_lines_played: 0,
            boot_cues: 0,
            keyboard: Keyboard::default(),
            show_keyboard: true,
            scan_opened: None,
            ai: SharedAi::default(),
            show_ai: false,
            ai_provider: PROVIDERS.into_iter().find(|p| p.configured()).unwrap_or(Provider::Anthropic),
            camera: Camera::default(),
            show_camera: false,
            cam_texture: None,
            cam_seq: 0,
            cam_mirror: true,
            cam_holo: true,
            cam_note: None,
            home: start_dir,
            scanner: Scanner::default(),
            show_threats: false,
            booted: false,
            ctx,
        }
    }

    fn restart_terminal(&mut self) {
        match Terminal::new(self.ctx.clone(), &self.files.cwd) {
            Ok(t) => {
                self.term = Some(t);
                self.term_err = None;
            }
            Err(e) => {
                self.term = None;
                self.term_err = Some(e);
            }
        }
    }

    fn handle_input(&mut self, events: &[egui::Event]) {
        let enter = key_pressed(events, egui::Key::Enter);
        let dead = self.term.as_ref().map_or(true, |t| t.exited());
        if dead {
            if enter {
                self.sound.play(Sfx::Granted);
                self.restart_terminal();
            }
            return;
        }
        let Some(term) = self.term.as_mut() else { return };
        let app_cursor = term.application_cursor();
        for e in events {
            let Some(bytes) = terminal::event_to_bytes(e, app_cursor) else { continue };
            term.write(&bytes);
            if bytes == b"\r" {
                self.sound.play(Sfx::Enter);
            } else if self.last_key_sound.elapsed() > Duration::from_millis(25) {
                self.sound.play(Sfx::Key);
                self.last_key_sound = Instant::now();
            }
        }
    }

    fn boot_screen(&mut self, ctx: &egui::Context, events: &[egui::Event]) {
        let skip = events.iter().any(|e| {
            matches!(
                e,
                egui::Event::Key { pressed: true, .. } | egui::Event::PointerButton { pressed: true, .. }
            )
        });
        let elapsed = self.boot_start.elapsed().as_secs_f32();
        let shown = (elapsed * BOOT_SPEED) as usize;
        if skip || shown > BOOT_LOG.len() + BOOT_HOLD {
            self.booted = true;
            ctx.request_repaint();
            return;
        }

        // Sound cues: the eye awakens, blinks twice; a glitch per log line; a chord at the end.
        let cues = [(EYE_OPEN.0 - 0.05, Sfx::Awaken), (BLINKS[0], Sfx::Blink), (BLINKS[1], Sfx::Blink)];
        for (i, &(at, sfx)) in cues.iter().enumerate() {
            if elapsed >= at && self.boot_cues & (1 << i) == 0 {
                self.boot_cues |= 1 << i;
                self.sound.play(sfx);
            }
        }
        while self.boot_lines_played < shown.min(BOOT_LOG.len() + 1) {
            if self.boot_lines_played == BOOT_LOG.len() {
                self.sound.play(Sfx::Granted);
            } else {
                self.sound.play(Sfx::Blip);
            }
            self.boot_lines_played += 1;
        }

        let t = self.theme;
        let time = ctx.input(|i| i.time);
        let tf = time as f32;
        let progress = (elapsed * BOOT_SPEED / BOOT_LOG.len() as f32).min(1.0);
        let done = shown >= BOOT_LOG.len();
        let user = std::env::var("USERNAME").or_else(|_| std::env::var("USER")).unwrap_or_default();
        let pointer = ctx.input(|i| i.pointer.hover_pos());
        w::backdrop(ctx, &t, time);

        egui::CentralPanel::default().frame(egui::Frame::none()).show(ctx, |ui| {
            let full = ui.max_rect().shrink(30.0);
            let p = ui.painter();
            let c = full.center() - vec2(0.0, 50.0);

            // Scanner: counter-rotating segmented rings.
            let rings: [(f32, f32, usize, f32); 4] = [(150.0, 0.6, 3, 2.0), (172.0, -0.35, 6, 1.0), (196.0, 0.22, 2, 3.0), (222.0, -0.12, 10, 1.0)];
            for (i, &(r, speed, segs, width)) in rings.iter().enumerate() {
                let color = if i % 2 == 0 { t.primary } else { t.accent };
                let n = segs as f32;
                for k in 0..segs {
                    let a0 = tf * speed + k as f32 * TAU / n;
                    w::arc(p, c, r, a0, a0 + TAU / n * 0.55, Stroke::new(width, color.gamma_multiply(0.85)));
                }
            }

            // The eye: opens, looks around, blinks twice, then locks onto the pointer.
            let mut openness = eye::ease(elapsed, EYE_OPEN.0, EYE_OPEN.1);
            for &b in &BLINKS {
                if (b..b + 0.22).contains(&elapsed) {
                    openness *= (2.0 * (elapsed - b) / 0.22 - 1.0).abs().powf(0.7);
                }
            }
            let look = if elapsed < EYE_OPEN.1 {
                vec2(0.0, 0.3)
            } else if elapsed < BLINKS[0] {
                let s = elapsed - EYE_OPEN.1;
                vec2((s * 2.4).sin() * 0.9, (s * 1.3).sin() * 0.4)
            } else {
                pointer.map_or(egui::Vec2::ZERO, |m| ((m - c) / 300.0).clamp(vec2(-1.0, -1.0), vec2(1.0, 1.0)))
            };
            let dilation = 1.7 - 0.9 * eye::ease(elapsed, 2.0, 3.6) + if done { 0.15 * (tf * 3.0).sin() } else { 0.0 };
            eye::eye(p, c, 112.0, 58.0, &EyeState { openness, look, dilation }, t.bg, time);

            p.circle_stroke(c, 128.0, Stroke::new(1.0_f32, t.alpha(50)));
            w::arc(p, c, 128.0, -FRAC_PI_2, -FRAC_PI_2 + TAU * progress, Stroke::new(4.0_f32, t.accent));
            p.text(c + vec2(0.0, 98.0), Align2::CENTER_CENTER, format!("{:>3.0}%", progress * 100.0), FontId::monospace(13.0), t.alpha(200));

            if done {
                w::glitch_text(p, c + vec2(0.0, 248.0), Align2::CENTER_CENTER, "D A E M O N", FontId::monospace(30.0), &t, time * 2.0);
            } else if elapsed < EYE_OPEN.1 {
                let a = (120.0 + 100.0 * (tf * 4.0).sin()) as u8;
                p.text(c + vec2(0.0, 248.0), Align2::CENTER_CENTER, "AWAKENING", FontId::monospace(13.0), egui::Color32::from_rgba_unmultiplied(255, 70, 50, a));
            }

            // Status line and progress bar under the scanner.
            let bar = egui::Rect::from_center_size(c + vec2(0.0, 300.0), vec2(460.0, 4.0));
            w::progress(p, bar, &t, progress);
            let status = if done {
                format!("I SEE YOU, {}", user.to_uppercase())
            } else {
                BOOT_LOG[shown.min(BOOT_LOG.len() - 1)].to_string()
            };
            p.text(bar.center_top() - vec2(0.0, 10.0), Align2::CENTER_BOTTOM, status, FontId::monospace(13.0), t.text);

            // Recent subsystem log, bottom-left.
            let visible = &BOOT_LOG[shown.min(BOOT_LOG.len()).saturating_sub(8)..shown.min(BOOT_LOG.len())];
            for (j, line) in visible.iter().rev().enumerate() {
                let y = full.bottom() - j as f32 * 18.0;
                let a = 200u8.saturating_sub(j as u8 * 22);
                p.text(egui::pos2(full.left(), y), Align2::LEFT_BOTTOM, format!("› {line}"), FontId::monospace(11.0), t.alpha(a));
            }

            p.text(full.left_top(), Align2::LEFT_TOP, "DAEMON OS  //  v2050.1", FontId::monospace(12.0), t.alpha(170));
            p.text(
                full.right_top(),
                Align2::RIGHT_TOP,
                chrono::Local::now().format("%Y.%m.%d  %H:%M:%S").to_string(),
                FontId::monospace(12.0),
                t.alpha(170),
            );
            p.text(full.right_bottom(), Align2::RIGHT_BOTTOM, "press any key to skip", FontId::monospace(11.0), t.alpha(110));
        });
        ctx.request_repaint();
    }

    /// Returns the action of a clicked status pill, so every panel can be opened with the
    /// mouse (on many laptops F1–F12 are media keys unless Fn is held).
    fn top_bar(&self, ui: &mut egui::Ui, s: &Snapshot, time: f64) -> Option<Action> {
        let t = &self.theme;
        let mut clicked = None;
        let pill = |ui: &mut egui::Ui, text: String, c: egui::Color32| {
            ui.label(RichText::new(format!("  {text}  ")).color(c).background_color(c.gamma_multiply(0.14)).size(11.0));
        };
        let button = |ui: &mut egui::Ui, text: String, c: egui::Color32, action: Action, clicked: &mut Option<Action>| {
            let label = egui::Label::new(RichText::new(format!("  {text}  ")).color(c).background_color(c.gamma_multiply(0.14)).size(11.0))
                .sense(Sense::click());
            if ui.add(label).on_hover_cursor(egui::CursorIcon::PointingHand).clicked() {
                *clicked = Some(action);
            }
        };
        ui.horizontal(|ui| {
            let (rect, _) = ui.allocate_exact_size(vec2(110.0, 22.0), Sense::hover());
            let center = rect.left_center() + vec2(13.0, 0.0);
            // Mini eye: blinks every few seconds and follows the mouse.
            let look = ui
                .input(|i| i.pointer.hover_pos())
                .map_or(egui::Vec2::ZERO, |m| ((m - center) / 400.0).clamp(vec2(-1.0, -1.0), vec2(1.0, 1.0)));
            let state = EyeState { openness: eye::blink(time, 5.5), look, dilation: 0.8 };
            eye::eye(ui.painter(), center, 13.0, 7.0, &state, t.bg, time);
            w::glitch_text(ui.painter(), rect.left_center() + vec2(34.0, 0.0), Align2::LEFT_CENTER, "DAEMON", FontId::monospace(15.0), t, time);
            ui.label(RichText::new("NEURAL OPERATING INTERFACE  ·  v2050.1").color(t.alpha(120)).size(11.0));
            ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
                let user = std::env::var("USERNAME").or_else(|_| std::env::var("USER")).unwrap_or_default();
                ui.label(RichText::new(format!("{user}@{}", s.hostname)).color(t.alpha(170)).size(11.0));
                let dot = if (time * 1.5) as i64 % 2 == 0 { "●" } else { "○" };
                let net = self.net.lock().unwrap().clone();
                match (net.online, net.latency_ms) {
                    (Some(true), Some(ms)) => pill(ui, format!("{dot} ONLINE  {ms} ms"), t.accent),
                    (Some(false), _) => pill(ui, "✕ OFFLINE".into(), t.alert),
                    _ => pill(ui, "… CHECKING LINK".into(), t.alpha(180)),
                }
                if !self.sound.available() {
                    pill(ui, "NO AUDIO".into(), t.alert);
                } else if self.sound.muted() {
                    button(ui, "SOUND OFF  [F10]".into(), t.alert, Action::Sound, &mut clicked);
                } else {
                    button(ui, "SOUND ON  [F10]".into(), t.primary, Action::Sound, &mut clicked);
                }
                button(ui, "DEEP SCAN [F9]".into(), t.alpha(200), Action::DeepScan, &mut clicked);
                button(ui, "AI [F7]".into(), t.alpha(200), Action::Ai, &mut clicked);
                if self.camera.shared.lock().unwrap().status == CamStatus::Live {
                    button(ui, format!("{dot} CAM LIVE  [F6]"), t.alert, Action::Camera, &mut clicked);
                } else {
                    button(ui, "CAMERA [F6]".into(), t.alpha(200), Action::Camera, &mut clicked);
                }
                let scan = self.scanner.shared.lock().unwrap().clone();
                match (&scan.status, scan.started) {
                    (ScanStatus::Running, Some(at)) => {
                        let text = format!("{dot} SCANNING {}  [F5]", clock(at.elapsed().as_secs()));
                        button(ui, text, t.accent, Action::Threats, &mut clicked);
                    }
                    (ScanStatus::Threats(list), _) => {
                        button(ui, format!("⚠ {} THREATS  [F5]", list.len()), t.alert, Action::Threats, &mut clicked);
                    }
                    _ => button(ui, "THREAT SCAN [F5]".into(), t.alpha(200), Action::Threats, &mut clicked),
                }
            });
        });
        clicked
    }

    fn left_panel(&self, ui: &mut egui::Ui, s: &Snapshot) {
        let t = &self.theme;
        let now = chrono::Local::now();
        ui.label(RichText::new(now.format("%H:%M:%S").to_string()).font(FontId::monospace(44.0)).color(t.primary));
        ui.label(RichText::new(now.format("%A %d %B %Y").to_string().to_uppercase()).color(t.alpha(160)));

        w::header(ui, t, "SYSTEM", &s.hostname);
        w::kv(ui, t, "OS", &s.os);
        w::kv(ui, t, "KERNEL", &s.kernel);
        w::kv(ui, t, "UPTIME", &fmt_duration(s.uptime));
        w::kv(ui, t, "CPU", &s.cpu_brand);

        w::header(ui, t, "CPU USAGE", &format!("{} CORES  {:>3.0}%", s.cores.len(), s.cpu_total));
        w::graph(ui, t, &[(&s.cpu_history, t.primary)], 100.0, 60.0);
        ui.add_space(4.0);
        w::core_bars(ui, t, &s.cores);

        let mem_frac = if s.mem_total > 0 { s.mem_used as f32 / s.mem_total as f32 } else { 0.0 };
        w::header(ui, t, "MEMORY", &format!("{} / {}", fmt_bytes(s.mem_used), fmt_bytes(s.mem_total)));
        w::mem_grid(ui, t, mem_frac);
        ui.add_space(2.0);
        w::kv(ui, t, "SWAP", &format!("{} / {}", fmt_bytes(s.swap_used), fmt_bytes(s.swap_total)));

        w::header(ui, t, "TOP PROCESSES", &format!("{} RUNNING", s.proc_count));
        egui::Grid::new("procs").num_columns(4).spacing(vec2(8.0, 2.0)).show(ui, |ui| {
            for h in ["PID", "NAME", "CPU", "MEM"] {
                ui.label(RichText::new(h).color(t.alpha(120)).size(10.0));
            }
            ui.end_row();
            for p in &s.procs {
                ui.label(RichText::new(p.pid.to_string()).size(10.0).color(t.alpha(170)));
                ui.label(RichText::new(truncate(&p.name, 16)).size(10.0));
                let cpu_color = if p.cpu > 50.0 { t.alert } else { t.primary };
                ui.label(RichText::new(format!("{:.1}%", p.cpu)).size(10.0).color(cpu_color));
                ui.label(RichText::new(fmt_bytes(p.mem)).size(10.0));
                ui.end_row();
            }
        });
    }

    fn right_panel(&self, ui: &mut egui::Ui, s: &Snapshot, time: f64) {
        let t = &self.theme;
        let net = self.net.lock().unwrap().clone();
        let online = net.online == Some(true);

        w::header(ui, t, "GLOBAL NETWORK", if online { "TRACKING" } else { "NO SIGNAL" });
        globe::globe(ui, t, time, 250.0);

        w::header(ui, t, "NETWORK STATUS", &s.net_iface);
        w::kv(ui, t, "INTERNET", internet_label(&net));
        w::kv(ui, t, "LATENCY", &net.latency_ms.map_or("--".into(), |l| format!("{l} ms")));
        if let Some(since) = net.since {
            w::kv(ui, t, if online { "ONLINE SINCE" } else { "OFFLINE SINCE" }, &since.format("%H:%M:%S").to_string());
        }
        let max_latency = net.latency_history.iter().cloned().fold(50.0_f32, f32::max);
        ui.add_space(4.0);
        w::graph(ui, t, &[(&net.latency_history, if online { t.accent } else { t.alert })], max_latency * 1.2, 32.0);
        ui.add_space(4.0);
        w::kv(ui, t, "DOWNLOAD", &format!("{}/s", fmt_bytes(s.rx_rate)));
        w::kv(ui, t, "UPLOAD", &format!("{}/s", fmt_bytes(s.tx_rate)));
        let max = s.rx_history.iter().chain(s.tx_history.iter()).cloned().fold(1024.0_f32, f32::max);
        ui.add_space(4.0);
        w::graph(ui, t, &[(&s.rx_history, t.primary), (&s.tx_history, t.accent)], max * 1.1, 70.0);
        ui.add_space(4.0);
        w::kv(ui, t, "TOTAL RX", &fmt_bytes(s.rx_total));
        w::kv(ui, t, "TOTAL TX", &fmt_bytes(s.tx_total));

        w::header(ui, t, "STORAGE", &format!("{} VOLUMES", s.disks.len()));
        for d in &s.disks {
            let frac = if d.total > 0 { d.used as f32 / d.total as f32 } else { 0.0 };
            let label = if d.name.is_empty() { d.mount.clone() } else { format!("{} {}", d.mount, d.name) };
            w::kv(ui, t, &truncate(&label, 18), &format!("{} / {}", fmt_bytes(d.used), fmt_bytes(d.total)));
            w::bar(ui, t, frac);
            ui.add_space(4.0);
        }

        w::header(ui, t, "CONTROLS", "");
        w::kv(ui, t, "THEME", &t.name.to_uppercase());
        w::kv(ui, t, "SOUND [F10]", if self.sound.muted() { "OFF" } else { "ON" });
        w::kv(ui, t, "CUSTOM SOUNDS", &self.sound.custom_count().to_string());
        w::kv(ui, t, "DEEP SCAN", "F9");
        let ready = PROVIDERS.iter().filter(|p| p.configured()).count();
        w::kv(ui, t, "AI MODELS [F7]", &format!("{ready} / {} READY", PROVIDERS.len()));
        w::kv(ui, t, "CAMERA [F6]", if self.camera.running() { "LIVE" } else { "OFF" });
        w::kv(ui, t, "THREAT SCAN", "F5");
        w::kv(ui, t, "KEYBOARD [F8]", if self.show_keyboard { "ON" } else { "OFF" });
        w::kv(ui, t, "FULLSCREEN", "F11");
        w::kv(ui, t, "SCROLLBACK", "MOUSE WHEEL");
    }

    /// Floating "AI" panel: sends a CPU / memory / disk summary to one or more LLMs on request.
    fn ai_panel(&mut self, ctx: &egui::Context, s: &Snapshot, time: f64) {
        let t = self.theme;
        let sel = self.ai_provider;
        let state = self.ai.lock().unwrap().clone();
        let run = state.run(sel);
        let running = state.running(sel);
        let configured: Vec<Provider> = PROVIDERS.into_iter().filter(|p| p.configured()).collect();
        let screen = ctx.screen_rect();
        let size = vec2(640.0_f32.min(screen.width() - 80.0), 560.0_f32.min(screen.height() - 120.0));
        let rect = egui::Rect::from_center_size(screen.center(), size);
        let spinner = ["◐", "◓", "◑", "◒"][(time * 6.0) as usize % 4];
        let mut pick = None;
        let mut start: Vec<Provider> = Vec::new();

        egui::Area::new(egui::Id::new("ai_panel"))
            .order(egui::Order::Foreground)
            .fixed_pos(rect.min)
            .show(ctx, |ui| {
                ui.painter().rect_filled(rect, 10.0, t.bg.gamma_multiply(0.97));
                ui.painter().rect_stroke(rect, 10.0, Stroke::new(1.0_f32, t.alpha(90)));
                w::corners(ctx, rect.expand(4.0), t.accent_alpha(200));
                ui.allocate_new_ui(egui::UiBuilder::new().max_rect(rect.shrink(16.0)), |ui| {
                    w::header(ui, &t, "NEURAL LINK  //  MULTI-MODEL ANALYSIS", "F7 / ESC  CLOSE");

                    // Provider tabs: ● ready, ○ not set up, ✓ answered, ✕ failed.
                    ui.horizontal_wrapped(|ui| {
                        for p in PROVIDERS {
                            let mark = match state.runs.get(&p).map(|r| &r.status) {
                                Some(Status::Running) => spinner,
                                Some(Status::Done(_)) => "✓",
                                Some(Status::Error(_)) => "✕",
                                _ if p.configured() => "●",
                                _ => "○",
                            };
                            let color = if p == sel {
                                t.accent
                            } else if p.configured() {
                                t.primary
                            } else {
                                t.alpha(110)
                            };
                            let text = RichText::new(format!("{mark} {}", p.label())).color(color).size(11.0);
                            if ui.selectable_label(p == sel, text).clicked() {
                                pick = Some(p);
                            }
                        }
                    });
                    ui.add_space(4.0);

                    w::kv(ui, &t, "MODEL", &sel.model());
                    let key_state = if !sel.needs_key() {
                        "NOT NEEDED (LOCAL)".to_string()
                    } else if sel.key().is_some() {
                        format!("SET ({})", sel.key_var())
                    } else {
                        format!("NOT SET ({})", sel.key_var())
                    };
                    w::kv(ui, &t, "API KEY", &key_state);
                    if sel == Provider::Ollama {
                        w::kv(ui, &t, "ENDPOINT", &sel.url());
                    }
                    ui.add_space(6.0);

                    if sel.key().is_none() {
                        let var = sel.key_var();
                        ui.label(
                            RichText::new(format!(
                                "Set the {var} environment variable, then restart DAEMON.\n\n\
                                 Windows:        setx {var} \"...\"\n\
                                 macOS / Linux:  export {var}=\"...\"\n\n\
                                 Create a key at {}. Override the model with {}.",
                                sel.signup(),
                                sel.model_var()
                            ))
                            .color(t.alpha(200)),
                        );
                        return;
                    }

                    ui.horizontal(|ui| {
                        let button = |label: &str| {
                            egui::Button::new(RichText::new(label).color(t.accent).size(13.0))
                                .fill(t.accent_alpha(25))
                                .stroke(Stroke::new(1.0_f32, t.accent_alpha(150)))
                        };
                        let label = if running { "ANALYZING…".to_string() } else { format!("▶ ASK {}", sel.label()) };
                        if ui.add_enabled(!running, button(&label)).clicked() {
                            start.push(sel);
                        }
                        let idle: Vec<Provider> = configured.iter().copied().filter(|&p| !state.running(p)).collect();
                        let all = button(&format!("▶▶ ANALYZE ALL ({})", configured.len()));
                        if ui.add_enabled(!idle.is_empty(), all).on_hover_text("Ask every configured model at once").clicked() {
                            start.extend(idle);
                        }
                        if running {
                            let dots = ".".repeat((time * 3.0) as usize % 3 + 1);
                            ui.label(RichText::new(format!("waiting for {}{dots}", sel.label())).color(t.alpha(170)));
                        } else if let Some(at) = run.finished_at {
                            let took = run.took.map_or(String::new(), |d| format!(" in {:.1} s", d.as_secs_f32()));
                            ui.label(RichText::new(format!("last run {}{took}", at.format("%H:%M:%S"))).color(t.alpha(130)).size(11.0));
                        }
                    });
                    ui.label(
                        RichText::new("Sends only CPU, memory and disk usage (no host name, user name, files or camera).")
                            .color(t.alpha(110))
                            .size(10.0),
                    );
                    ui.add_space(6.0);

                    egui::ScrollArea::vertical().id_salt("ai_scroll").auto_shrink([false, false]).show(ui, |ui| {
                        match &run.status {
                            Status::Idle => {
                                ui.label(
                                    RichText::new(format!(
                                        "Press ASK {} to analyze this machine's current load, or ANALYZE ALL to compare every configured model.",
                                        sel.label()
                                    ))
                                    .color(t.alpha(160)),
                                );
                            }
                            Status::Running => {}
                            Status::Done(text) => {
                                if run.model != sel.model() {
                                    ui.label(RichText::new(format!("answered by {}", run.model)).color(t.alpha(120)).size(10.0));
                                }
                                ui.label(RichText::new(text).color(t.text));
                            }
                            Status::Error(e) => {
                                ui.label(RichText::new(e).color(t.alert));
                            }
                        }
                        if !run.sent.is_empty() {
                            ui.add_space(8.0);
                            ui.collapsing(RichText::new("DATA SENT").color(t.alpha(150)).size(11.0), |ui| {
                                ui.label(RichText::new(&run.sent).color(t.alpha(150)).size(10.0));
                            });
                        }
                    });
                });
            });

        if let Some(p) = pick {
            self.ai_provider = p;
            self.sound.play(Sfx::Click);
        }
        let mut started = false;
        for p in start {
            started |= ai::analyze(&self.ai, p, s, ctx.clone());
        }
        if started {
            self.sound.play(Sfx::Scan);
        }
    }

    fn overlay_open(&self) -> bool {
        self.scan_opened.is_some() || self.show_ai || self.show_camera || self.show_threats
    }

    /// Opens or closes a panel; opening one floating panel closes the others.
    fn act(&mut self, action: Action, time: f64) {
        match action {
            Action::Sound => self.sound.toggle_mute(),
            Action::DeepScan => {
                self.scan_opened = match self.scan_opened {
                    Some(_) => None,
                    None => {
                        self.sound.play(Sfx::Scan);
                        Some(time)
                    }
                };
            }
            Action::Camera => {
                if self.show_camera {
                    self.close_camera();
                } else {
                    self.open_camera();
                }
            }
            Action::Ai => {
                let open = !self.show_ai;
                self.close_floating();
                self.show_ai = open;
            }
            Action::Threats => {
                let open = !self.show_threats;
                self.close_floating();
                self.show_threats = open;
                if open {
                    self.scanner.refresh_protection(self.ctx.clone());
                }
            }
        }
    }

    fn close_floating(&mut self) {
        if self.show_camera {
            self.close_camera();
        }
        self.show_ai = false;
        self.show_threats = false;
    }

    fn open_camera(&mut self) {
        self.close_floating();
        self.show_camera = true;
        self.cam_note = None;
        self.sound.play(Sfx::Awaken);
        let index = self.camera.shared.lock().unwrap().active;
        self.camera.start(index, self.ctx.clone());
    }

    /// Closing the panel releases the camera.
    fn close_camera(&mut self) {
        self.show_camera = false;
        self.camera.stop();
        self.cam_texture = None;
    }

    /// Floating "OPTIC SENSOR" panel: live webcam feed with a holographic HUD.
    fn camera_panel(&mut self, ctx: &egui::Context, time: f64) {
        let t = self.theme;
        let st = self.camera.shared.lock().unwrap().clone();
        if let Some(f) = st.frame.as_ref().filter(|_| st.seq != self.cam_seq) {
            let img = egui::ColorImage::from_rgb([f.width as usize, f.height as usize], &f.rgb);
            match &mut self.cam_texture {
                Some(tex) => tex.set(img, egui::TextureOptions::LINEAR),
                None => self.cam_texture = Some(ctx.load_texture("camera", img, egui::TextureOptions::LINEAR)),
            }
            self.cam_seq = st.seq;
        }

        let screen = ctx.screen_rect();
        let size = vec2(800.0_f32.min(screen.width() - 80.0), 620.0_f32.min(screen.height() - 100.0));
        let rect = egui::Rect::from_center_size(screen.center(), size);
        let cam_on = self.camera.running();
        let live = cam_on && st.status == CamStatus::Live;
        let blink = (time * 2.0) as i64 % 2 == 0;
        let (mut snap, mut next, mut toggle) = (false, false, false);
        let (mut mirror, mut holo) = (self.cam_mirror, self.cam_holo);

        egui::Area::new(egui::Id::new("camera_panel"))
            .order(egui::Order::Foreground)
            .fixed_pos(rect.min)
            .show(ctx, |ui| {
                ui.painter().rect_filled(rect, 10.0, t.bg.gamma_multiply(0.97));
                ui.painter().rect_stroke(rect, 10.0, Stroke::new(1.0_f32, t.alpha(90)));
                w::corners(ctx, rect.expand(4.0), t.accent_alpha(200));
                ui.allocate_new_ui(egui::UiBuilder::new().max_rect(rect.shrink(16.0)), |ui| {
                    w::header(ui, &t, "OPTIC SENSOR  //  CAMERA FEED", "F6 / ESC  CLOSE");
                    let device = st.devices.get(st.active).cloned().unwrap_or_else(|| "--".into());
                    let count = if st.devices.len() > 1 { format!("  ({}/{})", st.active + 1, st.devices.len()) } else { String::new() };
                    w::kv(ui, &t, "DEVICE", &format!("{}{count}", truncate(&device, 40)));
                    w::kv(ui, &t, "FORMAT", if st.format.is_empty() { "--" } else { &st.format });
                    w::kv(ui, &t, "STREAM", &if live { format!("{:.0} FPS", st.fps) } else { "--".into() });
                    ui.add_space(6.0);

                    // Viewport: the feed, letterboxed to keep its aspect ratio.
                    let view = ui.allocate_exact_size(vec2(ui.available_width(), ui.available_height() - 64.0), Sense::hover()).0;
                    let p = ui.painter_at(view);
                    p.rect_filled(view, 6.0, egui::Color32::BLACK);
                    let feed = match (&self.cam_texture, &st.frame) {
                        (Some(tex), Some(f)) if live => {
                            let scale = (view.width() / f.width as f32).min(view.height() / f.height as f32);
                            let r = egui::Rect::from_center_size(view.center(), vec2(f.width as f32, f.height as f32) * scale);
                            let uv = if mirror {
                                egui::Rect::from_min_max(egui::pos2(1.0, 0.0), egui::pos2(0.0, 1.0))
                            } else {
                                egui::Rect::from_min_max(egui::pos2(0.0, 0.0), egui::pos2(1.0, 1.0))
                            };
                            let tint = if holo { crate::theme::lerp_color(egui::Color32::WHITE, t.primary, 0.45) } else { egui::Color32::WHITE };
                            p.image(tex.id(), r, uv, tint);
                            Some(r)
                        }
                        _ => None,
                    };

                    match (feed, &st.status) {
                        (Some(r), _) => {
                            // HUD: scan sweep, scanlines, reticle, labels.
                            if holo {
                                let mut y = r.top();
                                while y < r.bottom() {
                                    p.hline(r.x_range(), y, Stroke::new(1.0_f32, egui::Color32::from_black_alpha(40)));
                                    y += 3.0;
                                }
                            }
                            let sweep = r.top() + ((time * 0.35).fract() as f32) * r.height();
                            p.hline(r.x_range(), sweep, Stroke::new(2.0_f32, t.accent_alpha(110)));
                            let c = r.center();
                            let rr = r.height().min(r.width()) * 0.12;
                            p.circle_stroke(c, rr, Stroke::new(1.0_f32, t.accent_alpha(170)));
                            w::arc(&p, c, rr * 1.35, time as f32, time as f32 + 1.2, Stroke::new(2.0_f32, t.accent_alpha(200)));
                            w::arc(&p, c, rr * 1.35, time as f32 + TAU / 2.0, time as f32 + TAU / 2.0 + 1.2, Stroke::new(2.0_f32, t.accent_alpha(200)));
                            for d in [vec2(1.0, 0.0), vec2(-1.0, 0.0), vec2(0.0, 1.0), vec2(0.0, -1.0)] {
                                p.line_segment([c + d * rr * 0.4, c + d * rr * 0.8], Stroke::new(1.0_f32, t.accent_alpha(200)));
                            }
                            let tl = r.left_top() + vec2(10.0, 10.0);
                            if blink {
                                p.circle_filled(tl + vec2(5.0, 7.0), 5.0, t.alert);
                            }
                            p.text(tl + vec2(16.0, 0.0), Align2::LEFT_TOP, "LIVE", FontId::monospace(13.0), t.alert);
                            p.text(r.right_top() + vec2(-10.0, 10.0), Align2::RIGHT_TOP, "SUBJECT TRACKING", FontId::monospace(11.0), t.alpha(200));
                            p.text(
                                r.right_bottom() - vec2(10.0, 10.0),
                                Align2::RIGHT_BOTTOM,
                                chrono::Local::now().format("%Y.%m.%d  %H:%M:%S").to_string(),
                                FontId::monospace(11.0),
                                t.alpha(220),
                            );
                            w::corners(ctx, r.shrink(4.0), t.accent_alpha(220));
                        }
                        (None, CamStatus::Error(e)) => {
                            p.text(view.center() - vec2(0.0, 12.0), Align2::CENTER_CENTER, "✕ OPTIC SENSOR OFFLINE", FontId::monospace(16.0), t.alert);
                            p.text(view.center() + vec2(0.0, 14.0), Align2::CENTER_CENTER, truncate(e, 90), FontId::monospace(11.0), t.alpha(200));
                        }
                        (None, CamStatus::Off) => {
                            p.text(view.center(), Align2::CENTER_CENTER, "CAMERA OFF  —  PRESS START", FontId::monospace(14.0), t.alpha(170));
                        }
                        (None, _) => {
                            let dots = ".".repeat((time * 3.0) as usize % 3 + 1);
                            p.text(view.center(), Align2::CENTER_CENTER, format!("INITIALIZING OPTIC SENSOR{dots}"), FontId::monospace(14.0), t.primary);
                        }
                    }

                    ui.add_space(8.0);
                    ui.horizontal(|ui| {
                        let button = |label: &str, c: egui::Color32| {
                            egui::Button::new(RichText::new(label).color(c).size(12.0))
                                .fill(c.gamma_multiply(0.12))
                                .stroke(Stroke::new(1.0_f32, c.gamma_multiply(0.6)))
                        };
                        snap = ui.add_enabled(live && st.frame.is_some(), button("◉ SNAPSHOT", t.accent)).clicked();
                        if st.devices.len() > 1 {
                            next = ui.add(button("⇄ NEXT CAMERA", t.primary)).clicked();
                        }
                        toggle = ui.add(button(if cam_on { "■ STOP" } else { "▶ START" }, if cam_on { t.alert } else { t.accent })).clicked();
                        if ui.add(button(if mirror { "MIRROR: ON" } else { "MIRROR: OFF" }, t.alpha(200))).clicked() {
                            mirror = !mirror;
                        }
                        if ui.add(button(if holo { "FILTER: HOLO" } else { "FILTER: RAW" }, t.alpha(200))).clicked() {
                            holo = !holo;
                        }
                    });
                    let note = match &self.cam_note {
                        Some((msg, err)) => RichText::new(msg).color(if *err { t.alert } else { t.accent }),
                        None => RichText::new("Video stays on this machine. The camera is released when this panel closes.").color(t.alpha(110)),
                    };
                    ui.label(note.size(10.0));
                });
            });

        self.cam_mirror = mirror;
        self.cam_holo = holo;
        if snap {
            if let Some(f) = &st.frame {
                self.sound.play(Sfx::Click);
                let dir = camera::snapshot_dir(&self.home);
                self.cam_note = Some(match camera::save_snapshot(f, &dir) {
                    Ok(path) => (format!("SNAPSHOT SAVED  →  {}", path.display()), false),
                    Err(e) => (e, true),
                });
            }
        }
        if next {
            self.sound.play(Sfx::Click);
            self.camera.next(ctx.clone());
        }
        if toggle {
            if self.camera.running() {
                self.camera.stop();
                self.cam_texture = None;
            } else {
                self.camera.start(st.active, ctx.clone());
            }
        }
    }

    /// Floating "THREAT SCAN" panel: antivirus status and quick / full malware scans.
    fn threats_panel(&mut self, ctx: &egui::Context, time: f64) {
        let t = self.theme;
        let st = self.scanner.shared.lock().unwrap().clone();
        let running = st.status == ScanStatus::Running;
        let screen = ctx.screen_rect();
        let size = vec2(680.0_f32.min(screen.width() - 80.0), 580.0_f32.min(screen.height() - 100.0));
        let rect = egui::Rect::from_center_size(screen.center(), size);
        let (mut start, mut cancel) = (None, false);

        egui::Area::new(egui::Id::new("threat_scan"))
            .order(egui::Order::Foreground)
            .fixed_pos(rect.min)
            .show(ctx, |ui| {
                ui.painter().rect_filled(rect, 10.0, t.bg.gamma_multiply(0.97));
                ui.painter().rect_stroke(rect, 10.0, Stroke::new(1.0_f32, t.alpha(90)));
                w::corners(ctx, rect.expand(4.0), t.accent_alpha(200));
                ui.allocate_new_ui(egui::UiBuilder::new().max_rect(rect.shrink(16.0)), |ui| {
                    let engine = if st.engine.is_empty() { if cfg!(windows) { "MICROSOFT DEFENDER" } else { "CLAMAV" }.to_string() } else { st.engine.to_uppercase() };
                    w::header(ui, &t, "THREAT SCAN  //  MALWARE DETECTION", "F5 / ESC  CLOSE");
                    w::kv(ui, &t, "ENGINE", &engine);
                    if st.protection.is_empty() {
                        w::kv(ui, &t, "PROTECTION", "QUERYING…");
                    }
                    for (k, v, ok) in &st.protection {
                        ui.horizontal(|ui| {
                            ui.label(RichText::new(k).color(t.alpha(150)));
                            ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
                                ui.label(RichText::new(v).color(if *ok { t.text } else { t.alert }));
                            });
                        });
                    }
                    ui.add_space(8.0);

                    ui.horizontal(|ui| {
                        let button = |label: &str, c: egui::Color32| {
                            egui::Button::new(RichText::new(label).color(c).size(13.0))
                                .fill(c.gamma_multiply(0.12))
                                .stroke(Stroke::new(1.0_f32, c.gamma_multiply(0.6)))
                        };
                        if ui.add_enabled(!running, button("▶ QUICK SCAN", t.accent)).on_hover_text("Places malware usually hides: a few minutes").clicked() {
                            start = Some(ScanKind::Quick);
                        }
                        if ui.add_enabled(!running, button("▶▶ FULL SYSTEM SCAN", t.accent)).on_hover_text("Every file on every drive: can take an hour or more").clicked() {
                            start = Some(ScanKind::Full);
                        }
                        if running && ui.add(button("■ CANCEL", t.alert)).clicked() {
                            cancel = true;
                        }
                    });
                    ui.add_space(8.0);

                    // Status display.
                    let (area, _) = ui.allocate_exact_size(vec2(ui.available_width(), 96.0), Sense::hover());
                    let p = ui.painter_at(area);
                    let c = area.left_center() + vec2(48.0, 0.0);
                    let (title, detail, color) = match &st.status {
                        ScanStatus::Idle => ("READY".to_string(), "Choose a quick scan or a full system scan.".to_string(), t.alpha(180)),
                        ScanStatus::Running => {
                            let kind = st.kind.map_or("SCAN", ScanKind::label);
                            let elapsed = st.started.map_or(0, |s| s.elapsed().as_secs());
                            (format!("{kind} IN PROGRESS  {}", clock(elapsed)), "You can close this panel; the scan keeps running.".to_string(), t.accent)
                        }
                        ScanStatus::Clean => ("✓ NO THREATS FOUND".to_string(), format!("{} finished cleanly.", st.kind.map_or("Scan", ScanKind::label)), t.accent),
                        ScanStatus::Threats(list) => (format!("⚠ {} THREAT(S) DETECTED", list.len()), "Review them below and remove them in Windows Security / your antivirus.".to_string(), t.alert),
                        ScanStatus::Cancelled => ("SCAN CANCELLED".to_string(), String::new(), t.alpha(180)),
                        ScanStatus::Error(e) => ("✕ SCAN FAILED".to_string(), e.clone(), t.alert),
                    };
                    // Radar: sweeps while scanning, solid when done.
                    p.circle_stroke(c, 36.0, Stroke::new(1.0_f32, color.gamma_multiply(0.6)));
                    p.circle_stroke(c, 22.0, Stroke::new(1.0_f32, color.gamma_multiply(0.4)));
                    if running {
                        let a = time as f32 * 2.5;
                        for k in 0..12 {
                            let a0 = a - k as f32 * 0.08;
                            w::arc(&p, c, 30.0, a0, a0 + 0.08, Stroke::new(12.0_f32, color.gamma_multiply(1.0 - k as f32 / 12.0)));
                        }
                    } else {
                        p.circle_filled(c, 10.0, color.gamma_multiply(0.8));
                    }
                    let x = area.left() + 104.0;
                    p.text(egui::pos2(x, area.center().y - 12.0), Align2::LEFT_CENTER, title, FontId::monospace(18.0), color);
                    p.text(egui::pos2(x, area.center().y + 14.0), Align2::LEFT_CENTER, truncate(&detail, 70), FontId::monospace(11.0), t.alpha(190));
                    if let (Some(took), Some(at)) = (st.took, st.finished_at) {
                        if !running {
                            p.text(area.right_top(), Align2::RIGHT_TOP, format!("{}  ·  took {}", at.format("%H:%M:%S"), clock(took.as_secs())), FontId::monospace(10.0), t.alpha(130));
                        }
                    }

                    egui::ScrollArea::vertical().id_salt("threat_scroll").auto_shrink([false, false]).show(ui, |ui| {
                        if let ScanStatus::Threats(list) = &st.status {
                            for th in list {
                                ui.label(RichText::new(format!("⚠ {}", th.name)).color(t.alert));
                                if !th.path.is_empty() {
                                    ui.label(RichText::new(format!("   {}", th.path)).color(t.alpha(180)).size(10.0));
                                }
                            }
                        }
                        if let ScanStatus::Error(e) = &st.status {
                            ui.label(RichText::new(e).color(t.alert).size(11.0));
                        }
                        if !st.log.trim().is_empty() {
                            ui.add_space(6.0);
                            ui.collapsing(RichText::new("ENGINE OUTPUT").color(t.alpha(150)).size(11.0), |ui| {
                                ui.label(RichText::new(st.log.trim()).color(t.alpha(150)).size(10.0));
                            });
                        }
                        ui.add_space(6.0);
                        ui.label(
                            RichText::new("DAEMON only reports what the antivirus engine finds; it does not delete or quarantine files itself.")
                                .color(t.alpha(110))
                                .size(10.0),
                        );
                    });
                });
            });

        if let Some(kind) = start {
            self.sound.play(Sfx::Scan);
            self.scanner.start(kind, ctx.clone());
        }
        if cancel {
            self.sound.play(Sfx::Click);
            self.scanner.cancel();
        }
    }

    /// Full-screen "deep scan" listing everything known about the machine.
    fn scan_overlay(&self, ctx: &egui::Context, s: &Snapshot, opened: f64, time: f64) {
        let t = self.theme;
        let screen = ctx.screen_rect();
        let ppp = ctx.pixels_per_point();
        let mut sections = s.intel.clone();
        let net = self.net.lock().unwrap().clone();
        sections.push((
            "CONNECTIVITY".to_string(),
            vec![
                ("INTERNET".into(), internet_label(&net).into()),
                ("LATENCY".into(), net.latency_ms.map_or("--".into(), |l| format!("{l} ms"))),
                ("STATE SINCE".into(), net.since.map_or("--".into(), |d| d.format("%Y-%m-%d %H:%M:%S").to_string())),
                ("PROBE".into(), "TCP handshake to 1.1.1.1 / 8.8.8.8 every 5 s".into()),
            ],
        ));
        sections.push((
            "DISPLAY".to_string(),
            vec![
                ("RESOLUTION".into(), format!("{:.0} × {:.0} px", screen.width() * ppp, screen.height() * ppp)),
                ("SCALE".into(), format!("{:.0}%", ppp * 100.0)),
                ("UI SIZE".into(), format!("{:.0} × {:.0} pt", screen.width(), screen.height())),
            ],
        ));
        // Rows appear progressively, like a scan in progress.
        let reveal = ((time - opened) * 90.0) as usize;

        egui::Area::new(egui::Id::new("deep_scan"))
            .order(egui::Order::Tooltip)
            .fixed_pos(screen.min)
            .show(ctx, |ui| {
                let bg = t.bg;
                ui.painter().rect_filled(screen, 0.0, egui::Color32::from_rgba_unmultiplied(bg.r(), bg.g(), bg.b(), 252));
                w::corners(ctx, screen.shrink(18.0), t.accent_alpha(200));
                ui.allocate_new_ui(egui::UiBuilder::new().max_rect(screen.shrink(40.0)), |ui| {
                    ui.horizontal(|ui| {
                        let (rect, _) = ui.allocate_exact_size(vec2(40.0, 30.0), Sense::hover());
                        let state = EyeState { openness: eye::blink(time, 4.0), look: vec2((time.sin() * 0.8) as f32, 0.0), dilation: 0.7 };
                        eye::eye(ui.painter(), rect.center(), 18.0, 10.0, &state, bg, time);
                        let (rect, _) = ui.allocate_exact_size(vec2(520.0, 30.0), Sense::hover());
                        w::glitch_text(ui.painter(), rect.left_center(), Align2::LEFT_CENTER, "DEEP SCAN  //  SYSTEM INTEL", FontId::monospace(22.0), &t, time);
                        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
                            ui.label(RichText::new("F9 / ESC  CLOSE").color(t.alpha(150)).size(11.0));
                        });
                    });
                    ui.add_space(6.0);
                    egui::ScrollArea::vertical().auto_shrink([false, false]).show(ui, |ui| {
                        ui.spacing_mut().item_spacing.x = 36.0;
                        ui.columns(4, |cols| {
                            let mut shown = 0;
                            for (i, (title, rows)) in sections.iter().enumerate() {
                                let col = &mut cols[i % 4];
                                if shown >= reveal {
                                    break;
                                }
                                w::header(col, &t, title, &format!("{} ITEMS", rows.len()));
                                for (k, v) in rows {
                                    if shown >= reveal {
                                        break;
                                    }
                                    w::kv(col, &t, k, v);
                                    shown += 1;
                                }
                                col.add_space(10.0);
                            }
                        });
                    });
                });
            });
    }
}

impl eframe::App for DaemonApp {
    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
        // Keep keyboard focus away from egui widgets: every key belongs to the terminal.
        ctx.memory_mut(|m| {
            if let Some(id) = m.focused() {
                m.surrender_focus(id);
            }
        });

        let events = ctx.input(|i| i.events.clone());
        let time = ctx.input(|i| i.time);
        if key_pressed(&events, egui::Key::F11) {
            let fs = ctx.input(|i| i.viewport().fullscreen.unwrap_or(false));
            ctx.send_viewport_cmd(egui::ViewportCommand::Fullscreen(!fs));
        }
        if key_pressed(&events, egui::Key::F10) {
            self.sound.toggle_mute();
        }

        if !self.booted {
            self.boot_screen(ctx, &events);
            return;
        }

        if key_pressed(&events, egui::Key::F8) {
            self.show_keyboard = !self.show_keyboard;
        }
        let overlay_was_open = self.overlay_open();
        for (key, action) in [
            (egui::Key::F5, Action::Threats),
            (egui::Key::F6, Action::Camera),
            (egui::Key::F7, Action::Ai),
            (egui::Key::F9, Action::DeepScan),
        ] {
            if key_pressed(&events, key) {
                self.act(action, time);
            }
        }
        // Esc closes the topmost overlay.
        if key_pressed(&events, egui::Key::Escape) {
            if self.scan_opened.is_some() {
                self.scan_opened = None;
            } else if self.show_camera {
                self.close_camera();
            } else {
                self.show_ai = false;
                self.show_threats = false;
            }
        }

        // While an overlay is open (or was just closed), keystrokes don't reach the shell.
        if !overlay_was_open && !self.overlay_open() {
            self.handle_input(&events);
            self.keyboard.observe(&events);
        }
        let snap = self.stats.lock().unwrap().clone();
        let t = self.theme;

        w::backdrop(ctx, &t, time);

        // Ambient "data chatter" every few seconds.
        if time > self.next_chatter {
            self.sound.play(Sfx::Chatter);
            self.next_chatter = time + 6.0 + self.rng.next_f32() as f64 * 12.0;
        }

        let clicked = egui::TopBottomPanel::top("top")
            .frame(egui::Frame::none().inner_margin(Margin::symmetric(16.0, 8.0)))
            .show(ctx, |ui| self.top_bar(ui, &snap, time))
            .inner;
        if let Some(action) = clicked {
            self.act(action, time);
        }

        let hidden = egui::scroll_area::ScrollBarVisibility::AlwaysHidden;

        egui::SidePanel::left("left")
            .exact_width(SIDE_WIDTH)
            .resizable(false)
            .frame(gap_frame())
            .show(ctx, |ui| {
                glass(ui, &t, |ui| {
                    egui::ScrollArea::vertical()
                        .id_salt("left_scroll")
                        .scroll_bar_visibility(hidden)
                        .show(ui, |ui| self.left_panel(ui, &snap));
                })
            });

        egui::SidePanel::right("right")
            .exact_width(SIDE_WIDTH)
            .resizable(false)
            .frame(gap_frame())
            .show(ctx, |ui| {
                glass(ui, &t, |ui| {
                    egui::ScrollArea::vertical()
                        .id_salt("right_scroll")
                        .scroll_bar_visibility(hidden)
                        .show(ui, |ui| self.right_panel(ui, &snap, time));
                })
            });

        egui::TopBottomPanel::bottom("files")
            .exact_height(220.0)
            .resizable(false)
            .frame(gap_frame())
            .show(ctx, |ui| {
                glass(ui, &t, |ui| {
                    w::header(ui, &t, "FILESYSTEM", &self.files.cwd.display().to_string());
                    if let Some(action) = self.files.show(ui, &t) {
                        self.sound.play(Sfx::Click);
                        let cmd = match action {
                            FileAction::Cd(p) => format!("cd \"{}\"\r", p.display()),
                            FileAction::Insert(p) => format!("\"{}\" ", p.display()),
                        };
                        if let Some(term) = self.term.as_mut() {
                            term.write(cmd.as_bytes());
                        }
                    }
                })
            });

        egui::CentralPanel::default().frame(gap_frame()).show(ctx, |ui| {
            glass(ui, &t, |ui| {
                w::header(ui, &t, "TERMINAL", "NEURAL SHELL  //  TTY0");
                ui.add_space(4.0);
                // The on-screen keyboard takes a strip at the bottom of the terminal panel.
                let kb_height = if self.show_keyboard { (ui.available_height() * 0.32).min(160.0) } else { 0.0 };
                let term_size = vec2(ui.available_width(), ui.available_height() - kb_height);
                ui.allocate_ui(term_size, |ui| match (self.term.as_mut(), &self.term_err) {
                    (Some(term), _) => term.show(ui, &t),
                    (None, err) => {
                        ui.colored_label(t.alert, format!(
                            "FAILED TO START SHELL: {}\n\nPress ENTER to retry. Set DAEMON_SHELL to choose a different shell.",
                            err.as_deref().unwrap_or("unknown error")
                        ));
                    }
                });
                if self.show_keyboard {
                    if let Some(bytes) = self.keyboard.show(ui, &t, kb_height) {
                        self.sound.play(if bytes == b"\r" { Sfx::Enter } else { Sfx::Key });
                        if let Some(term) = self.term.as_mut() {
                            term.write(&bytes);
                        }
                    }
                }
            })
        });

        if self.show_ai {
            self.ai_panel(ctx, &snap, time);
        }
        if self.show_camera {
            self.camera_panel(ctx, time);
        }
        if self.show_threats {
            self.threats_panel(ctx, time);
        }

        if let Some(opened) = self.scan_opened {
            self.scan_overlay(ctx, &snap, opened, time);
        }

        if t.retro {
            w::scanlines(ctx);
        }

        // Globe, eye, scanlines and cursor are animated: ~30 fps.
        ctx.request_repaint_after(Duration::from_millis(33));
    }
}