headroom

//! `headroom monitor` tui — bus gauges, loudness, per-stream routing.

//!

//! main thread owns terminal + draw loop; reader thread owns the `Client`,

//! forwards events over a channel. no graceful reader shutdown — process

//! exit tears the socket down.

use std::collections::BTreeMap;

use std::io;

use std::thread;

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

use crossbeam_channel::{select, tick, unbounded, Receiver};

use crossterm::event::{self, Event as CtEvent, KeyCode, KeyEvent, KeyModifiers};

use headroom_client::{Client, ClientError};

use headroom_ipc::{

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

    StreamRoute, Topic,

};

use ratatui::{

    layout::{Alignment, Constraint, Direction, Layout, Rect},

    style::{Color, Modifier, Style, Stylize},

    text::{Line, Span},

    widgets::{Block, Borders, Cell, Clear, Gauge, Paragraph, Row, Table, Wrap},

    Frame, Terminal,

};

#[derive(Debug, thiserror::Error)]

pub enum TuiError {

    #[error("client: {0}")]

    Client(#[from] ClientError),

    #[error("terminal: {0}")]

    Io(#[from] io::Error),

}

/// runs initial rpcs, then hands the client to the reader thread and

/// enters the draw loop.

pub fn run(mut client: Client) -> Result<(), TuiError> {

    // subscribe + initial state before raw mode.

    let topics = [Topic::Meters, Topic::Routing, Topic::Profile, Topic::Daemon];

    client.subscribe(&topics)?;

    let status = client.status()?;

    let route_list = client.route_list()?;

    // client is single-connection + the reader owns it for events; open a

    // second connection for control (keypress ops).

    let mut control = Client::connect_at(client.socket_path())?;

    let (tx, rx) = unbounded::<Msg>();

    let reader_handle = thread::Builder::new()

        .name("headroom-monitor-rx".into())

        .spawn(move || reader_loop(client, tx))

        .map_err(TuiError::Io)?;

    let mut terminal = ratatui::init();

    let outcome = draw_loop(&mut terminal, status, route_list, rx, &mut control);

    ratatui::restore();

    // detach: process exit / dropped channel tears the connection down.

    drop(reader_handle);

    outcome

}

// ---------------------------------------------------------------------------

// Reader thread

// ---------------------------------------------------------------------------

enum Msg {

    Event(Event),

    Disconnected(String),

}

fn reader_loop(mut client: Client, tx: crossbeam_channel::Sender<Msg>) {

    loop {

        match client.next_event() {

            Ok(ev) => {

                if tx.send(Msg::Event(ev)).is_err() {

                    return;

                }

            }

            Err(e) => {

                let _ = tx.send(Msg::Disconnected(e.to_string()));

                return;

            }

        }

    }

}

// ---------------------------------------------------------------------------

// State

// ---------------------------------------------------------------------------

struct UiState {

    daemon_version: String,

    profile: String,

    bypass: bool,

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

    per_app_master: bool,

    /// overlay overrides shadowing the profile; flagged 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. presence = tap attached; inner = latest smoothed

    /// reduction (none until the first `layer_a_level`).

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

    /// richer layer a snapshots (ceiling/deferred/managed), polled from

    /// `per-app.list`; feeds the detail line.

    la_snapshots: BTreeMap<u32, LayerASnapshot>,

    /// selected stream node id; resolved against `streams` at draw time.

    selected: Option<u32>,

    meters: Option<MeterTick>,

    /// last tick arrival; drives staleness when the source goes silent.

    last_meter_at: Option<Instant>,

    overflow_total: u64,

    last_error: Option<String>,

    disconnected: Option<String>,

    /// modal profile picker; while `Some` it intercepts all keyboard input.

    picker: Option<ProfilePicker>,

}

/// modal profile-switcher; `selected` indexes `profiles`.

struct ProfilePicker {

    profiles: Vec<headroom_ipc::ProfileInfo>,

    selected: usize,

}

impl ProfilePicker {

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

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

        if self.profiles.is_empty() {

            return;

        }

        let n = self.profiles.len() as isize;

        self.selected = (self.selected as isize + delta).rem_euclid(n) as usize;

    }

}

/// initial highlight: active profile, else the daemon's current name, else top.

fn initial_picker_selection(profiles: &[headroom_ipc::ProfileInfo], current: &str) -> usize {

    profiles

        .iter()

        .position(|p| p.active)

        .or_else(|| profiles.iter().position(|p| p.name == current))

        .unwrap_or(0)

}

impl UiState {

    fn new(status: Status, route_list: headroom_ipc::RouteList) -> Self {

        let mut streams = BTreeMap::new();

        for s in route_list.current {

            streams.insert(s.node_id, s);

        }

        // `status.streams` is a superset; merge.

        for s in status.streams.iter() {

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

        }

        // seed layer a from status so table/detail are populated pre-poll.

        let mut la_snapshots = BTreeMap::new();

        let mut layer_a = 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);

        }

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

        Self {

            daemon_version: status.version,

            profile: status.profile,

            bypass: status.bypass,

            per_app_master: status.per_app,

            setting_overrides: status.setting_overrides,

            base_uptime_s: status.uptime_s,

            connected_at: Instant::now(),

            default_route: route_list.default_route,

            streams,

            layer_a,

            la_snapshots,

            selected,

            meters: None,

            last_meter_at: None,

            overflow_total: 0,

            last_error: None,

            disconnected: None,

            picker: None,

        }

    }

    fn uptime_s(&self) -> u64 {

        self.base_uptime_s

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

    }

    /// 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]);

    }

    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>(routing_payload(&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, .. } => {

                            // reduction unknown until the first `layer_a_level`.

                            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 => { /* tui doesn't show rules */ }

                        _ => {}

                    }

                }

            }

            Topic::Profile => {

                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();

                        }

                    }

                    _ => {}

                }

            }

            Topic::Daemon => {

                if let Ok(de) = serde_json::from_value::<DaemonEvent>(daemon_payload(&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());

                        }

                        DaemonEvent::Started { version } => {

                            self.daemon_version = version;

                        }

                        _ => {}

                    }

                }

            }

            _ => {}

        }

    }

}

/// typed event enums are `#[serde(tag = "event")]` but the wire frame keeps

/// `event` outside `data`, so re-inject it before deserializing.

fn routing_payload(ev: &Event) -> serde_json::Value {

    inject_event(&ev.event, &ev.data)

}

fn daemon_payload(ev: &Event) -> serde_json::Value {

    inject_event(&ev.event, &ev.data)

}

fn inject_event(event: &str, data: &serde_json::Value) -> serde_json::Value {

    let mut obj = match data {

        serde_json::Value::Object(m) => m.clone(),

        _ => serde_json::Map::new(),

    };

    obj.insert("event".into(), serde_json::Value::String(event.to_string()));

    serde_json::Value::Object(obj)

}

// ---------------------------------------------------------------------------

// Draw loop

// ---------------------------------------------------------------------------

fn draw_loop<B: ratatui::backend::Backend>(

    terminal: &mut Terminal<B>,

    status: Status,

    route_list: headroom_ipc::RouteList,

    rx: Receiver<Msg>,

    control: &mut Client,

) -> Result<(), TuiError> {

    let mut state = UiState::new(status, route_list);

    // 10 Hz redraw floor so uptime/staleness tick with no events flowing.

    let ticker = tick(Duration::from_millis(100));

    let input_rx = spawn_input_thread();

    // ~1 Hz poll of the richer layer a snapshot.

    let mut poll_ticks: u32 = 0;

    loop {

        terminal.draw(|f| draw(f, &state))?;

        select! {

            recv(rx) -> msg => match msg {

                Ok(Msg::Event(ev)) => state.apply_event(ev),

                Ok(Msg::Disconnected(reason)) => {

                    state.disconnected = Some(reason);

                    // final paint, then linger so the banner is seen.

                    terminal.draw(|f| draw(f, &state))?;

                    thread::sleep(Duration::from_millis(800));

                    return Ok(());

                }

                Err(_) => return Ok(()),

            },

            recv(input_rx) -> msg => match msg {

                Ok(InputMsg::Key(k)) => {

                    if handle_key(&mut state, control, k) {

                        return Ok(());

                    }

                }

                Ok(InputMsg::Redraw) => {}

                Err(_) => return Ok(()),

            },

            recv(ticker) -> _ => {

                poll_ticks = poll_ticks.wrapping_add(1);

                if poll_ticks % 10 == 0 {

                    poll_layer_a(&mut state, control);

                }

            }

        }

    }

}

/// refresh layer a snapshots from the control connection; errors go to the

/// footer (non-fatal — the event stream keeps the ui live).

fn poll_layer_a(state: &mut UiState, control: &mut Client) {

    match control.layer_a_list() {

        Ok(list) => {

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

        }

        Err(e) => {

            state.last_error = Some(format!("layer-a poll: {e}"));

        }

    }

}

/// apply a keypress: nav + toggles + per-row actions. control ops run

/// synchronously on the control connection; failures land in the footer.

/// returns `true` to quit.

fn handle_key(state: &mut UiState, control: &mut Client, k: KeyEvent) -> bool {

    // ctrl-c: hard exit, even with the picker open.

    if k.modifiers.contains(KeyModifiers::CONTROL)

        && matches!(k.code, KeyCode::Char('c') | KeyCode::Char('C'))

    {

        return true;

    }

    // picker is modal: while open it swallows every other key.

    if state.picker.is_some() {

        handle_picker_key(state, control, k);

        return false;

    }

    if is_quit(&k) {

        return true;

    }

    match k.code {

        KeyCode::Char('j') | KeyCode::Down => state.move_selection(1),

        KeyCode::Char('k') | KeyCode::Up => state.move_selection(-1),

        KeyCode::Char('P') => open_profile_picker(state, control),

        KeyCode::Char('b') => {

            let target = !state.bypass;

            match control.bypass_set(target) {

                Ok(()) => state.bypass = target,

                Err(e) => state.last_error = Some(format!("bypass: {e}")),

            }

        }

        KeyCode::Char('p') => {

            let target = !state.per_app_master;

            match control.per_app_master(target) {

                Ok(()) => state.per_app_master = target,

                Err(e) => state.last_error = Some(format!("per-app master: {e}")),

            }

        }

        KeyCode::Char('r') | KeyCode::Enter => {

            let Some(node) = state.effective_selection() else {

                return false;

            };

            let Some(stream) = state.streams.get(&node) else {

                return false;

            };

            let app = stream.app.clone();

            let to = match stream.route {

                Route::Processed => Route::Bypass,

                Route::Bypass => Route::Processed,

            };

            // prefer a persistent per-app rule (keyed by app label) so the

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

            // fall back to a one-shot per-stream reroute when no label.

            let result = if app.is_empty() {

                control.route_stream(node, to)

            } else {

                control.route_set(&app, to)

            };

            match result {

                Ok(()) => {

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

                        s.route = to;

                    }

                }

                Err(e) => state.last_error = Some(format!("route: {e}")),

            }

        }

        KeyCode::Char('a') => {

            let Some(node) = state.effective_selection() else {

                return false;

            };

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

                return false;

            };

            if app.is_empty() {

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

                return false;

            }

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

            if let Err(e) = control.per_app_set(&app, !managed) {

                state.last_error = Some(format!("per-app set: {e}"));

            }

        }

        KeyCode::Char('x') => {

            let Some(node) = state.effective_selection() else {

                return false;

            };

            if let Err(e) = control.layer_a_reset(node) {

                state.last_error = Some(format!("reset: {e}"));

            }

        }

        KeyCode::Char('c') => {

            // clear all overlay overrides; no-op when none.

            if state.setting_overrides.is_empty() {

                return false;

            }

            match control.setting_reset() {