headroom

//! `HeadroomApp` — iced application state + view; mirrors the tui's

//! read-only `UiState` (`crates/headroom-cli/src/tui.rs`).

//!

//! control ops never block the ui thread: sent over `cmd_tx` to the

//! control thread (`io.rs`), which replies over the same `rx` the ui

//! drains each tick. ui updates optimistically; daemon events + the

//! ~1 Hz `per-app.list` refresh reconcile.

use std::collections::BTreeMap;

use std::time::{Duration, Instant};

use crossbeam_channel::{Receiver, Sender};

use iced::alignment::Horizontal;

use iced::widget::{button, column, container, mouse_area, pick_list, progress_bar, row, scrollable, text};

use iced::{keyboard, time, Alignment, Background, Border, Color, Element, Length, Subscription};

use headroom_ipc::{

    DaemonEvent, Event, LayerALevel, LayerASnapshot, MeterTick, ProfileInfo, Route, RoutingEvent,

    StreamRoute, Topic,

};

use crate::io::{AppMsg, Bootstrap, ControlCmd, Snapshot};

/// loudness at/below this floor renders as "--". mirrors

/// `headroom_core::agc::LOUDNESS_FLOOR_LUFS`, inlined so the gui doesn't

/// pull in the audio/dsp crate.

const LOUDNESS_FLOOR_LUFS: f32 = -200.0;

/// meters older than this are dimmed (source went silent / suspended).

const STALE_AFTER: Duration = Duration::from_millis(500);

/// ui drain + repaint interval (~20 Hz); also advances uptime/staleness

/// text with no events flowing.

const POLL_INTERVAL: Duration = Duration::from_millis(50);

// palette — explicit colors mirroring the tui's intent.

const BG: u32 = 0x1e1e1e;

const PANEL_BG: u32 = 0x252526;

const TRACK_BG: u32 = 0x3a3a3a;

const FG: u32 = 0xd4d4d4;

const DIM: u32 = 0x808080;

const CYAN: u32 = 0x4ec9b0;

const MAGENTA: u32 = 0xc586c0;

const RED: u32 = 0xf44747;

const GREEN: u32 = 0x6a9955;

const YELLOW: u32 = 0xdcdcaa;

const BLACK: u32 = 0x101010;

/// tint behind the selected stream row.

const SEL_BG: u32 = 0x094771;

/// hover/press tint for header + row buttons.

const HOVER_BG: u32 = 0x37373a;

/// poll ticks between `per-app.list` refreshes — ~1 Hz at [`POLL_INTERVAL`].

const REFRESH_EVERY_TICKS: u32 = 20;

/// poll ticks between `profile.list` refreshes — ~10 s. the profile *set*

/// only changes on `profile reload`; the active profile updates instantly

/// via `profile.changed`.

const REFRESH_PROFILES_EVERY_TICKS: u32 = 200;

#[derive(Debug, Clone)]

pub enum Message {

    /// poll tick: drain `rx`, repaint, periodically refresh.

    Tick,

    /// a keypress / event we don't act on.

    Noop,

    /// select a stream row by node id (mouse click).

    Select(u32),

    /// move the selection up / down one row (k/↑, j/↓).

    SelectUp,

    SelectDown,

    ToggleBypass,

    TogglePerAppMaster,

    /// toggle a stream's route (processed ↔ bypass).

    ToggleRoute(u32),

    /// toggle per-app management for a stream's app.

    TogglePerApp(u32),

    /// reset a stream's layer a deference.

    ResetLayerA(u32),

    /// hotkey variants acting on the current selection.

    RouteSelected,

    PerAppSelected,

    ResetSelected,

    /// switch to the named profile (pick_list).

    ProfileSelected(String),

    /// clear all overlay setting overrides.

    ClearOverrides,

}

/// mirrored daemon snapshot plus the live event channel it drains.

pub struct HeadroomApp {

    daemon_version: String,

    profile: String,

    bypass: bool,

    /// layer a master switch (per-app level control enabled globally).

    per_app_master: bool,

    /// overlay overrides (dotted key → value) shadowing the profile;

    /// surfaced so a stale `headroom set` isn't invisible.

    setting_overrides: BTreeMap<String, serde_json::Value>,

    /// daemon uptime at connect, plus local elapsed.

    base_uptime_s: u64,

    connected_at: Instant,

    default_route: Route,

    streams: BTreeMap<u32, StreamRoute>,

    /// per-stream layer a reduction (dB). presence = managed; inner `None`

    /// until the first `layer_a_level`.

    layer_a: BTreeMap<u32, Option<f32>>,

    /// richer per-stream snapshots (managed/ceiling/deferred), polled from

    /// `per-app.list`; drives the per-app toggle target + row label.

    la_snapshots: BTreeMap<u32, LayerASnapshot>,

    /// profiles for the switcher (seeded at connect).

    profiles: Vec<ProfileInfo>,

    /// selected stream node id; resolved via [`Self::effective_selection`].

    selected: Option<u32>,

    meters: Option<MeterTick>,

    last_meter_at: Option<Instant>,

    overflow_total: u64,

    last_error: Option<String>,

    disconnected: Option<String>,

    /// live event + worker stream from the reader / control threads.

    rx: Receiver<AppMsg>,

    /// hands control ops to the control thread.

    cmd_tx: Sender<ControlCmd>,

    /// poll-tick counter for the paced `per-app.list` refresh.

    tick_count: u32,

}

impl HeadroomApp {

    /// seed initial state from the snapshot, take ownership of the channel.

    pub fn new(boot: Bootstrap) -> Self {

        let Bootstrap {

            snapshot,

            rx,

            cmd_tx,

        } = boot;

        let mut app = Self {

            daemon_version: String::new(),

            profile: String::new(),

            bypass: false,

            per_app_master: false,

            setting_overrides: BTreeMap::new(),

            base_uptime_s: 0,

            connected_at: Instant::now(),

            default_route: Route::Processed,

            streams: BTreeMap::new(),

            layer_a: BTreeMap::new(),

            la_snapshots: BTreeMap::new(),

            profiles: Vec::new(),

            selected: None,

            meters: None,

            last_meter_at: None,

            overflow_total: 0,

            last_error: None,

            disconnected: None,

            rx,

            cmd_tx,

            tick_count: 0,

        };

        app.apply_snapshot(snapshot);

        // initial selection: first stream row (reconnects preserve the

        // user's selection, so this only runs at startup).

        app.selected = app.streams.keys().next().copied();

        app

    }

    /// replace mirrored daemon state from a fresh [`Snapshot`]. shared by

    /// [`Self::new`] + [`Self::reseed`]; leaves `selected` / channels /

    /// tick counter to the caller.

    fn apply_snapshot(&mut self, snapshot: Snapshot) {

        let Snapshot {

            status,

            route_list,

            profiles,

        } = snapshot;

        let mut streams = BTreeMap::new();

        for s in route_list.current {

            streams.insert(s.node_id, s);

        }

        // `status.streams` is a superset; merge any not already present.

        for s in status.streams.iter() {

            streams.entry(s.node_id).or_insert_with(|| s.clone());

        }

        // seed meter column + richer snapshots from status (mirrors tui).

        let mut layer_a = BTreeMap::new();

        let mut la_snapshots = BTreeMap::new();

        for snap in status.layer_a {

            layer_a.insert(snap.node_id, Some(snap.reduction_db));

            la_snapshots.insert(snap.node_id, snap);

        }

        self.daemon_version = status.version;

        self.profile = status.profile;

        self.bypass = status.bypass;

        self.per_app_master = status.per_app;

        self.setting_overrides = status.setting_overrides;

        self.base_uptime_s = status.uptime_s;

        self.connected_at = Instant::now();

        self.default_route = route_list.default_route;

        self.streams = streams;

        self.layer_a = layer_a;

        self.la_snapshots = la_snapshots;

        self.profiles = profiles;

    }

    /// re-seed after the reader reconnected to a (possibly new) daemon.

    /// clears the disconnect/error banners + per-instance overflow counter

    /// (a restarted daemon resets its drop count). `selected` is preserved —

    /// `effective_selection` reconciles it against the new stream set.

    fn reseed(&mut self, snapshot: Snapshot) {

        self.apply_snapshot(snapshot);

        self.overflow_total = 0;

        self.last_error = None;

        self.disconnected = None;

        self.last_meter_at = None;

    }

    pub fn title(&self) -> String {

        "headroom monitor".to_string()

    }

    /// poll tick (`smol` backs `time::every`) + global keyboard input.

    /// `keyboard::listen` only surfaces keys not consumed by a focused

    /// widget, so the pick_list keeps its own arrow/enter handling.

    pub fn subscription(&self) -> Subscription<Message> {

        Subscription::batch([

            time::every(POLL_INTERVAL).map(|_| Message::Tick),

            keyboard::listen().map(map_key),

        ])

    }

    pub fn update(&mut self, message: Message) {

        match message {

            Message::Noop => {}

            Message::Tick => {

                self.pump();

                self.tick_count = self.tick_count.wrapping_add(1);

                if self.tick_count.is_multiple_of(REFRESH_EVERY_TICKS) {

                    // reconcile managed/ceiling/deferred state the event

                    // stream doesn't push (mirrors the tui's poll).

                    self.send_cmd(ControlCmd::RefreshLayerA);

                }

                if self.tick_count.is_multiple_of(REFRESH_PROFILES_EVERY_TICKS) {

                    // pick up profiles added/removed by `profile reload`.

                    self.send_cmd(ControlCmd::RefreshProfiles);

                }

            }

            Message::Select(id) => self.selected = Some(id),

            Message::SelectUp => self.move_selection(-1),

            Message::SelectDown => self.move_selection(1),

            Message::ToggleBypass => {

                let target = !self.bypass;

                self.send_cmd(ControlCmd::SetBypass(target));

                self.bypass = target; // optimistic; no bypass event from daemon

            }

            Message::TogglePerAppMaster => {

                let target = !self.per_app_master;

                self.send_cmd(ControlCmd::SetPerAppMaster(target));

                self.per_app_master = target;

            }

            Message::ToggleRoute(id) => self.toggle_route(id),

            Message::TogglePerApp(id) => self.toggle_per_app(id),

            Message::ResetLayerA(id) => self.reset_layer_a(id),

            Message::RouteSelected => {

                if let Some(id) = self.effective_selection() {

                    self.toggle_route(id);

                }

            }

            Message::PerAppSelected => {

                if let Some(id) = self.effective_selection() {

                    self.toggle_per_app(id);

                }

            }

            Message::ResetSelected => {

                if let Some(id) = self.effective_selection() {

                    self.reset_layer_a(id);

                }

            }

            Message::ProfileSelected(name) => {

                // optimistic: update the header now; the daemon's "used"

                // event reconciles a frame or two later (mirrors the tui).

                self.profile = name.clone();

                self.send_cmd(ControlCmd::UseProfile(name));

            }

            Message::ClearOverrides => {

                // optimistic: drop the indicator now; the daemon clears the

                // overlay and reapplies the profile's values.

                self.setting_overrides.clear();

                self.send_cmd(ControlCmd::ClearOverrides);

            }

        }

    }

    /// drain + apply every queued worker message.

    fn pump(&mut self) {

        while let Ok(msg) = self.rx.try_recv() {

            self.handle_msg(msg);

        }

    }

    fn handle_msg(&mut self, msg: AppMsg) {

        match msg {

            AppMsg::Event(ev) => self.apply_event(ev),

            AppMsg::Disconnected(reason) => self.disconnected = Some(reason),

            AppMsg::Reconnected(snapshot) => self.reseed(*snapshot),

            AppMsg::ControlError(e) => self.last_error = Some(e),

            AppMsg::Profiles(p) => {

                // reconcile the displayed profile from the `active` flag —

                // covers external `profile use` even if "used" was missed.

                if let Some(active) = p.iter().find(|x| x.active) {

                    self.profile = active.name.clone();

                }

                self.profiles = p;

            }

            AppMsg::LayerASnapshots(list) => {

                self.la_snapshots = list.into_iter().map(|s| (s.node_id, s)).collect();

            }

        }

    }

    /// queue a control op; a dead control thread lands in the footer.

    fn send_cmd(&mut self, cmd: ControlCmd) {

        if self.cmd_tx.send(cmd).is_err() {

            self.last_error = Some("control thread gone".into());

        }

    }

    /// stream node ids in row order (`BTreeMap` keys).

    fn ordered_nodes(&self) -> Vec<u32> {

        self.streams.keys().copied().collect()

    }

    /// `selected` when still live, else the first row, else `None`.

    fn effective_selection(&self) -> Option<u32> {

        match self.selected {

            Some(id) if self.streams.contains_key(&id) => Some(id),

            _ => self.streams.keys().next().copied(),

        }

    }

    /// move the selection by `delta` rows (negative = up), wrapping.

    fn move_selection(&mut self, delta: isize) {

        let nodes = self.ordered_nodes();

        if nodes.is_empty() {

            self.selected = None;

            return;

        }

        let cur = self

            .effective_selection()

            .and_then(|id| nodes.iter().position(|&n| n == id))

            .unwrap_or(0) as isize;

        let next = (cur + delta).rem_euclid(nodes.len() as isize) as usize;

        self.selected = Some(nodes[next]);

    }

    /// flip a stream's route, optimistically updating local state.

    ///

    /// prefer a *persistent* per-app rule (`route.set`, keyed by app label)

    /// so the route survives the app recreating its stream between tracks

    /// (Strawberry, mpv, …); fall back to a one-shot `route.stream` only

    /// when there's no label to key on. the optimistic update flips just

    /// this row; the daemon's reevaluate emits `stream_routed` for sibling

    /// streams of the same app, which `apply_event` reconciles.

    fn toggle_route(&mut self, node: u32) {

        let Some((app, cur)) = self.streams.get(&node).map(|s| (s.app.clone(), s.route)) else {

            return;

        };

        let to = match cur {

            Route::Processed => Route::Bypass,

            Route::Bypass => Route::Processed,

        };

        if app.is_empty() {

            self.send_cmd(ControlCmd::RouteStream { node_id: node, to });

        } else {

            self.send_cmd(ControlCmd::SetRoute { app, to });

        }

        if let Some(s) = self.streams.get_mut(&node) {

            s.route = to;

        }

    }

    /// toggle per-app management for a stream's app. guards an empty

    /// label; reconciliation comes from the poll.

    fn toggle_per_app(&mut self, node: u32) {

        let Some(app) = self.streams.get(&node).map(|s| s.app.clone()) else {

            return;

        };

        if app.is_empty() {

            self.last_error = Some("per-app: selected stream has no app label".into());

            return;

        }

        let managed = self.la_snapshots.get(&node).is_some_and(|s| s.managed);

        self.send_cmd(ControlCmd::SetPerApp {

            app,

            enabled: !managed,

        });

    }

    /// reset a stream's layer a deference.

    fn reset_layer_a(&mut self, node: u32) {

        self.send_cmd(ControlCmd::ResetLayerA { node_id: node });

    }

    fn uptime_s(&self) -> u64 {

        self.base_uptime_s

            .saturating_add(self.connected_at.elapsed().as_secs())

    }

    fn meters_stale(&self) -> bool {

        self.last_meter_at

            .map(|t| t.elapsed() > STALE_AFTER)

            .unwrap_or(true)

    }

    /// apply one wire event. ported from the tui's `apply_event`, minus

    /// the selection/snapshot bookkeeping the read-only gui doesn't need.

    fn apply_event(&mut self, ev: Event) {

        match ev.topic {

            Topic::Meters if ev.event == "tick" => {

                if let Ok(m) = serde_json::from_value::<MeterTick>(ev.data) {

                    self.meters = Some(m);

                    self.last_meter_at = Some(Instant::now());

                }

            }

            Topic::Meters if ev.event == "layer_a_level" => {

                if let Ok(l) = serde_json::from_value::<LayerALevel>(ev.data) {

                    self.layer_a.insert(l.node_id, Some(l.reduction_db));

                }

            }

            Topic::Routing => {

                if let Ok(re) = serde_json::from_value::<RoutingEvent>(inject_event(&ev)) {

                    match re {

                        RoutingEvent::StreamRouted { node_id, app, to } => {

                            self.streams.insert(

                                node_id,

                                StreamRoute {

                                    node_id,

                                    app,

                                    route: to,

                                },

                            );

                        }

                        RoutingEvent::StreamRemoved { node_id } => {

                            self.streams.remove(&node_id);

                            self.layer_a.remove(&node_id);

                            self.la_snapshots.remove(&node_id);

                        }

                        RoutingEvent::LayerAAttached { node_id, .. } => {

                            self.layer_a.entry(node_id).or_insert(None);

                        }

                        RoutingEvent::LayerADetached { node_id } => {

                            self.layer_a.remove(&node_id);

                            self.la_snapshots.remove(&node_id);

                        }

                        RoutingEvent::RuleChanged => {}

                        _ => {}

                    }

                }

            }

            Topic::Profile => {

                // the daemon emits `profile` "used" `{name}` on apply (not

                // the typed `ProfileEvent::Changed` "changed"/`previous`

                // shape), so read `name` directly and accept either spelling

                // — keeps the header in sync with a cli `profile use` too.

                // on "reloaded" the profile *set* may have changed.

                match ev.event.as_str() {

                    "used" | "changed" => {

                        if let Some(name) = ev.data.get("name").and_then(|v| v.as_str()) {

                            self.profile = name.to_string();

                        }

                    }

                    "reloaded" => self.send_cmd(ControlCmd::RefreshProfiles),

                    _ => {}

                }

            }

            Topic::Daemon => {

                if let Ok(de) = serde_json::from_value::<DaemonEvent>(inject_event(&ev)) {

                    match de {

                        DaemonEvent::Overflow {

                            lost, total_lost, ..

                        } => {

                            self.overflow_total = total_lost.max(self.overflow_total + lost as u64);

                        }

                        DaemonEvent::Error { code, message } => {

                            self.last_error = Some(format!("{code}: {message}"));

                        }

                        DaemonEvent::Shutdown => {

                            self.disconnected = Some("daemon shutdown".into());

                        }