use crate::app::{AppAction, PageContent};
 use crate::power_meter::{self, Meter, Mode};
 use cce_ui::widget::ScrollRegion;
 use cce_ui::layout::{lay_row, Cell, PageLayoutBuilder, PageFlow, RenderTarget};
 use cce_ui::scene::layout::Rect;
 use std::sync::Mutex;
 
 #[derive(Debug, Clone)]
 pub struct ProcessRow {
     pub pid: String,
     pub cpu: String,
     pub mem_pct: String,
     pub rss_kb: u64,
     pub command: String,
     /// Estimated draw from [`power_meter`]; None until the meter has two
     /// samples of this pid, or when nothing on the host reports watts.
     pub watts: Option<f32>,
     /// Context switches per second over the last interval — the honest
     /// signal for a process that burns power while looking idle.
     pub wakeups: Option<f32>,
 }
 
 /// The whole-machine side of the estimate, for the line above the list.
 #[derive(Debug, Clone, PartialEq)]
 pub struct PowerSummary {
     pub mode: Mode,
     pub total_w: Option<f32>,
     pub floor_w: Option<f32>,
     pub attributed_w: f32,
 }
 
 impl Default for PowerSummary {
     fn default() -> Self {
         Self { mode: Mode::Warming, total_w: None, floor_w: None, attributed_w: 0.0 }
     }
 }
 
 /// One meter for the page's lifetime: attribution is a delta between
 /// consecutive fetches, so the previous snapshot has to outlive the fetch.
 static METER: Mutex<Option<Meter>> = Mutex::new(None);
 
 /// Which column orders the list. Cpu is the default (ps sorts the fetch);
 /// Mem is the toggle — clicking a memory header switches to it, clicking
 /// again switches back.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
 pub enum ProcSort {
     #[default]
     Cpu,
     Mem,
     Power,
     Wakeups,
 }
 
 #[derive(Debug, Clone)]
 pub struct ProcessesState {
     pub loaded: bool,
     pub processes: Vec<ProcessRow>,
     pub cpu_list: ScrollRegion,
     /// Pids a kill was requested for, dimmed until the next refresh. The
     /// refresh clears it: a killed process is gone from the new list, and a
     /// survivor (EPERM, ignored TERM) un-dims — an honest "didn't die".
     pub killing: std::collections::HashSet<String>,
     /// Active sort column. Survives refreshes: Refreshed re-sorts the fresh
     /// list under this key rather than resetting to the fetch order.
     pub sort: ProcSort,
     pub power: PowerSummary,
 }
 
 impl Default for ProcessesState {
     fn default() -> Self {
         Self {
             loaded: false,
             processes: Vec::new(),
             cpu_list: ScrollRegion::new(24.0, 2.0).with_frame(false).with_sink_behind(true),
             killing: std::collections::HashSet::new(),
             sort: ProcSort::Cpu,
             power: PowerSummary::default(),
         }
     }
 }
 
 #[derive(Debug, Clone)]
 pub enum ProcessesMessage {
     Refreshed(ProcessesState),
     /// The row's Kill button (the `x` glyph): SIGTERM this pid.
     Kill(String),
     /// A column header click. Mem headers toggle (Mem ⇄ back to Cpu); the
     /// CPU % header always selects Cpu.
     SortBy(ProcSort),
     None,
 }
 
 /// Order rows under the active key, descending. Stable, so ties keep their
 /// relative fetch order. Cpu re-parses the ps figure — after a Mem spell the
 /// fetch order is long gone from the Vec.
 fn sort_rows(rows: &mut [ProcessRow], sort: ProcSort) {
     match sort {
         ProcSort::Cpu => rows.sort_by(|a, b| {
             let (av, bv) = (a.cpu.parse::<f32>().unwrap_or(0.0), b.cpu.parse::<f32>().unwrap_or(0.0));
             bv.partial_cmp(&av).unwrap_or(std::cmp::Ordering::Equal)
         }),
         ProcSort::Mem => rows.sort_by(|a, b| b.rss_kb.cmp(&a.rss_kb)),
         // Unknowns sink below every known figure, however small.
         ProcSort::Power => rows.sort_by(|a, b| {
             b.watts.unwrap_or(-1.0).partial_cmp(&a.watts.unwrap_or(-1.0)).unwrap_or(std::cmp::Ordering::Equal)
         }),
         ProcSort::Wakeups => rows.sort_by(|a, b| {
             b.wakeups.unwrap_or(-1.0).partial_cmp(&a.wakeups.unwrap_or(-1.0)).unwrap_or(std::cmp::Ordering::Equal)
         }),
     }
 }
 
 /// Watts to one decimal; a dash below 0.05 W, so hundreds of idle rows do
 /// not read as fake precision, and for rows the meter has no figure for.
 pub fn format_watts(w: Option<f32>) -> String {
     match w {
         Some(w) if w >= 0.05 => format!("{:.1}", w),
         _ => "\u{2014}".to_string(),
     }
 }
 
 pub fn format_wakeups(w: Option<f32>) -> String {
     match w {
         Some(w) if w >= 0.5 => format!("{:.0}", w),
         _ => "\u{2014}".to_string(),
     }
 }
 
 /// The line above the list: what was measured, what is baseline, what the
 /// column adds up to — and, when the column is dashes, why.
 pub fn summary_line(p: &PowerSummary) -> String {
     let how = match p.mode {
         Mode::Warming => return "Measuring power\u{2026}".to_string(),
         Mode::Unavailable => {
             return "Per-process power needs the battery discharging or readable RAPL counters  \u{00b7}  wakeups only"
                 .to_string()
         }
         Mode::Battery => "estimated from battery draw",
         Mode::Rapl => "RAPL",
     };
     let mut parts = Vec::new();
     if let Some(t) = p.total_w {
         parts.push(format!("{:.1} W total", t));
     }
     if let Some(f) = p.floor_w {
         parts.push(format!("{:.1} W baseline", f));
     }
     parts.push(format!("{:.1} W attributed to processes ({})", p.attributed_w, how));
     parts.join("  \u{00b7}  ")
 }
 
 /// nvidia-smi's draw figure, asked for only while the card is awake: the
 /// query itself would wake a suspended card, costing watts to report a zero.
 async fn dgpu_draw_w() -> Option<f64> {
     if !power_meter::dgpu_awake() {
         return None;
     }
     let out = tokio::process::Command::new("nvidia-smi")
         .args(["--query-gpu=power.draw", "--format=csv,noheader,nounits"])
         .output()
         .await
         .ok()?;
     if !out.status.success() {
         return None;
     }
     String::from_utf8_lossy(&out.stdout).lines().next()?.trim().parse().ok()
 }
 
 /// Process name from a `ps … cmd` field: basename of argv[0], so cce binaries
 /// longer than the kernel's 15-char `comm` cap display whole (`comm` showed
 /// "cce-system-inte"). Kernel threads (`[kworker/0:1]`) keep their brackets.
 pub fn command_display(cmd: &str) -> String {
     let first = cmd.split_whitespace().next().unwrap_or(cmd);
     if first.starts_with('[') {
         return first.to_string();
     }
     std::path::Path::new(first)
         .file_name()
         .and_then(|n| n.to_str())
         .unwrap_or(first)
         .to_string()
 }
 
 /// Humanized RSS from ps's KiB figure.
 pub fn format_rss(kb: u64) -> String {
     if kb >= 1_048_576 {
         format!("{:.1} GB", kb as f64 / 1_048_576.0)
     } else if kb >= 1024 {
         format!("{} MB", kb / 1024)
     } else {
         format!("{} KB", kb)
     }
 }
 
 pub async fn fetch_processes_state() -> ProcessesState {
     let dgpu_w = dgpu_draw_w().await;
     let attribution = tokio::task::spawn_blocking(move || {
         let snap = power_meter::sample(dgpu_w);
         METER.lock().unwrap().get_or_insert_with(Meter::new).tick(snap)
     })
     .await
     .ok();
     let power = attribution
         .as_ref()
         .map(|a| PowerSummary { mode: a.mode, total_w: a.total_w, floor_w: a.floor_w, attributed_w: a.attributed_w })
         .unwrap_or_default();
 
     let processes = {
         let mut list = Vec::new();
         if let Some(o) = tokio::process::Command::new("ps")
             .args(["-eo", "pid,%cpu,%mem,rss,cmd", "--sort=-%cpu"])
             .output().await.ok()
         {
             let text = String::from_utf8_lossy(&o.stdout);
             for line in text.lines().skip(1) {
                 let parts: Vec<&str> = line.split_whitespace().collect();
                 if parts.len() >= 5 {
                     let pp = parts[0]
                         .parse::<u32>()
                         .ok()
                         .and_then(|pid| attribution.as_ref().and_then(|a| a.per_pid.get(&pid)).copied());
                     list.push(ProcessRow {
                         pid: parts[0].to_string(),
                         cpu: parts[1].to_string(),
                         mem_pct: parts[2].to_string(),
                         rss_kb: parts[3].parse().unwrap_or(0),
                         command: command_display(&parts[4..].join(" ")),
                         watts: pp.and_then(|p| p.watts),
                         wakeups: pp.map(|p| p.wakeups_per_s),
                     });
                 }
             }
         }
         list
     };
 
     ProcessesState {
         loaded: true,
         processes,
         cpu_list: ScrollRegion::new(24.0, 2.0).with_frame(false).with_sink_behind(true),
         killing: std::collections::HashSet::new(),
         sort: ProcSort::Cpu,
         power,
     }
 }
 
 const TEXT_FG: [f32; 4] = [0.83, 0.83, 0.83, 1.0];
 const TEXT_DIM: [f32; 4] = [0.53, 0.53, 0.60, 1.0];
 /// The least room the table keeps on a short window.
 const LIST_MIN_H: f32 = 120.0;
 /// The table's header and row text sizes, and the sort chevron's.
 const HDR_SIZE: f32 = 11.0;
 const ROW_SIZE: f32 = 12.0;
 const CHEVRON: f32 = 9.0;
 /// The least room COMMAND keeps, in characters, before the table scrolls sideways.
 const COMMAND_MIN_CHARS: usize = 24;
 
 /// The table's columns in content space — PID, COMMAND, MEM, MEM %, CPU %, W, WAKE/s and
 /// Kill — and the content width they need. Each column is as wide as its header (and the
 /// sort chevron) or its widest likely value, whichever is wider; COMMAND takes the slack of
 /// a box wider than that, so a wide window shows the whole table and a narrow one scrolls
 /// it. They stand `list_gap` apart and in from the edges (`lay_row`).
 fn table_columns(box_w: f32, row_h: f32, kill_w: f32) -> ([Rect; 8], f32) {
     let gap = cce_ui::layout::list_gap();
     let w = |s: &str| crate::app::text_width(s, ROW_SIZE, None);
     let head = |s: &str, sortable: bool| {
         crate::app::text_width(s, HDR_SIZE, None) + if sortable { gap / 2.0 + CHEVRON } else { 0.0 }
     };
     let widths = [
         w("4194304").max(head("PID", false)),
         w(&"x".repeat(COMMAND_MIN_CHARS)),
         w("999.9 GB").max(head("MEM", true)),
         w("100.0%").max(head("MEM %", false)),
         w("1000.0%").max(head("CPU %", true)),
         w("99.9").max(head("W", true)),
         w("99999").max(head("WAKE/s", true)),
         kill_w,
     ];
     let needed = widths.iter().sum::<f32>() + gap * (widths.len() + 1) as f32;
     let content_w = needed.max(box_w);
     let cells: Vec<Cell> = widths
         .iter()
         .enumerate()
         .map(|(i, &wd)| Cell { width: wd, height: row_h, grow: i == 1 })
         .collect();
     let rects = lay_row(Rect { x: 0.0, y: 0.0, width: content_w, height: row_h }, &cells);
     (std::array::from_fn(|i| rects[i]), content_w)
 }
 
 pub fn view(state: &mut ProcessesState, cx: f32, cy: f32, cw: f32, ch: f32, root_focused: bool, sec_focused: &[bool], layout: &mut PageFlow, ctx: &mut cce_ui::context::UiContext) -> PageContent {
     let mut final_pc = PageContent::new();
     let sec_w = 320.0f32;
     let mut builder = PageLayoutBuilder::new(layout, cx, cy, cw, ch, sec_w).with_section_count(1);
 
     // ── Processes Section (label-less well) ──
     builder.add_section_spanned(&mut final_pc, "", 1, root_focused || sec_focused.first().copied().unwrap_or(false), |sec| {
         let mut form = sec.form();
         if !state.loaded {
             form.column().text("Loading processes...", 12.0, TEXT_FG);
             sec.place(form, ctx);
             return;
         }
         // The table fills the page: the well's floor lands at the page's bottom.
         form.fill_height((cy + ch) - form.top() - sec.bottom_inset());
         let cpu_list = &mut state.cpu_list;
         let processes = &state.processes;
         let killing = &state.killing;
         let sort = state.sort;
         let mut col = form.column();
         // Power summary line above the table.
         col.text(summary_line(&state.power), 11.0, TEXT_DIM);
         col.fill(LIST_MIN_H, move |pc, r, _| {
             let (list_box_x, list_box_y, list_box_w, list_box_h) = (r.x, r.y, r.width, r.height);
             let gap = cce_ui::layout::list_gap();
             // A row, and the header, are as tall as the region virtualizes rows at.
             let row_h = cpu_list.item_height;
             let header_h = row_h;
             let kill_h = cce_ui::layout::button_height();
 
             // Dissolved List (Phase 6v): scroll state + frame prims are app-owned. The
             // scrollable viewport starts below the header. Columns live in CONTENT space;
             // every draw subtracts scroll_x, and a table wider than the box scrolls.
             let (cols, content_w) = table_columns(list_box_w, row_h, kill_h);
             let [c_pid, c_cmd, c_rss, c_mem, c_cpu, c_watts, c_wake, c_kill] = cols;
             cpu_list.set_rect(list_box_x, list_box_y, list_box_w, list_box_h);
             cpu_list.set_content_w(content_w);
             // No band for the horizontal scrollbar: it rides the rows'
             // centre line, crossing the vertical one, behind the plate until
             // a scroll raises it.
             let rows_h = list_box_h - header_h - gap;
             cpu_list.update_bounds(processes.len(), list_box_y + header_h, rows_h);
             cpu_list.push_prims(pc);
 
             let ox = cpu_list.scroll_x;
             let at = |c: Rect| list_box_x + c.x - ox;
 
             // Header row is background-less (the well shows through); only the
             // divider separates it from the rows.
             pc.rect([0.18, 0.18, 0.24, 1.0], list_box_x, list_box_y + header_h, list_box_w, 1.0);
 
             // Header labels pan with the columns, clipped to the box. The
             // sortable ones (MEM, MEM %, CPU %, W, WAKE/s) are hit targets the
             // width of their column: the active key shows brighter with a
             // `chevron-down` glyph after it (the sort is always descending).
             // Both memory headers toggle the same Mem sort — one bigger
             // target, no distinction to learn.
             let hdr = |on: bool| if on { [0.78, 0.78, 0.85, 1.0] } else { TEXT_DIM };
             let hdr_y = crate::app::label_y_in(list_box_y, header_h, HDR_SIZE, None);
             pc.push_clip_rect(list_box_x, list_box_y, list_box_w, header_h);
             let header = |pc: &mut PageContent, label: &str, c: Rect, on: bool, chevron: bool| {
                 let x = at(c);
                 pc.text(label, x, hdr_y, HDR_SIZE, hdr(on));
                 if on && chevron {
                     let gx = x + crate::app::text_width(label, HDR_SIZE, None) + gap / 2.0;
                     let gy = list_box_y + (header_h - CHEVRON) / 2.0;
                     pc.icon("chevron-down", gx, gy, CHEVRON, CHEVRON, hdr(on));
                 }
             };
             header(pc, "PID", c_pid, false, false);
             header(pc, "COMMAND", c_cmd, false, false);
             header(pc, "MEM", c_rss, sort == ProcSort::Mem, true);
             header(pc, "MEM %", c_mem, sort == ProcSort::Mem, false);
             header(pc, "CPU %", c_cpu, sort == ProcSort::Cpu, true);
             header(pc, "W", c_watts, sort == ProcSort::Power, true);
             header(pc, "WAKE/s", c_wake, sort == ProcSort::Wakeups, true);
             // The hit targets, list-row style like the rows (plateless, washed on
             // hover), inside the header clip so they pan and cut with the labels.
             // They share no rect with the row buttons, so emission order is free.
             for (c, key) in [(c_rss, ProcSort::Mem), (c_mem, ProcSort::Mem), (c_cpu, ProcSort::Cpu), (c_watts, ProcSort::Power), (c_wake, ProcSort::Wakeups)] {
                 pc.list_row(at(c), list_box_y, c.width, header_h, AppAction::Processes(ProcessesMessage::SortBy(key)));
             }
             pc.pop_clip_rect();
 
             // Visible process rows, clipped to the rows' viewport — not on
             // into the reserve band below it, where the scroll region still
             // hands back a row starting there and its Kill button stood alone
             // under the list.
             pc.push_clip_rect(list_box_x, list_box_y + header_h, list_box_w, rows_h);
             for (idx, p) in processes.iter().enumerate() {
                 if let Some(draw_y) = cpu_list.get_item_draw_y(idx, 4.0) {
                     // The row itself, in the DE's list style: plateless,
                     // washed on hover. A transparent plain button here wore a
                     // control plate per row — the whole list read as a stack
                     // of carved rings. Viewport-fixed on purpose: the hover
                     // band spans the visible row whatever the horizontal pan.
                     let wash = lay_row(Rect { x: list_box_x, y: draw_y, width: list_box_w, height: row_h }, &[Cell::grow(row_h)])[0];
                     pc.list_row(wash.x, wash.y, wash.width, wash.height, AppAction::Processes(ProcessesMessage::None));
 
                     // A pending kill dims the row until the next refresh
                     // settles it (gone, or alive again = the kill didn't take).
                     let dim = killing.contains(&p.pid);
                     let fg = if dim { [0.45, 0.45, 0.50, 1.0] } else { [0.80, 0.80, 0.85, 1.0] };
                     let mem_fg = if dim { [0.45, 0.45, 0.50, 1.0] } else { [0.62, 0.72, 0.88, 1.0] };
                     let cpu_fg = if dim { [0.45, 0.45, 0.50, 1.0] } else { [0.56, 0.83, 0.56, 1.0] };
                     let watt_fg = if dim { [0.45, 0.45, 0.50, 1.0] } else { [0.90, 0.75, 0.45, 1.0] };
 
                     let ty = crate::app::label_y_in(draw_y, row_h, ROW_SIZE, None);
                     let cell = |pc: &mut PageContent, text: &str, c: Rect, color: [f32; 4]| {
                         let x = at(c);
                         pc.text_with_bounds(text, x, ty, ROW_SIZE, color, Some([x, ty - ROW_SIZE, x + c.width, ty + 2.0 * ROW_SIZE]));
                     };
                     cell(pc, &p.pid, c_pid, fg);
                     cell(pc, &p.command, c_cmd, fg);
                     cell(pc, &format_rss(p.rss_kb), c_rss, mem_fg);
                     cell(pc, &format!("{}%", p.mem_pct), c_mem, mem_fg);
                     cell(pc, &format!("{}%", p.cpu), c_cpu, cpu_fg);
                     cell(pc, &format_watts(p.watts), c_watts, watt_fg);
                     cell(pc, &format_wakeups(p.wakeups), c_wake, fg);
 
                     // Kill button, in content space like the columns. Emitted
                     // AFTER the row button on purpose: overlapping page
                     // buttons all see the click and the LAST take_click wins
                     // the dispatched action (input_handler's collect loop), so
                     // the Kill button beats the row's no-op exactly because it comes later.
                     if !dim {
                         // The `x` glyph in the danger tint; "Kill" only if
                         // the icon set is missing.
                         pc.button_icon_tinted(
                             "x",
                             "Kill",
                             at(c_kill),
                             draw_y + (row_h - kill_h) / 2.0,
                             c_kill.width,
                             kill_h,
                             [0.0, 0.0, 0.0, 0.0],
                             [0.75, 0.30, 0.30, 0.45],
                             [0.85, 0.55, 0.55, 1.0],
                             AppAction::Processes(ProcessesMessage::Kill(p.pid.clone())),
                         );
                     }
                 }
             }
             pc.pop_clip_rect();
             // The scrollbar's fore copy, over the rows at the raise's fade.
             cpu_list.push_scrollbar_fore(pc);
 
             if processes.is_empty() {
                 pc.text("No active processes", list_box_x + gap, list_box_y + header_h + gap, 12.0, TEXT_DIM);
             }
         });
         sec.place(form, ctx);
     });
 
     final_pc
 }
 
 pub fn update(state: &mut ProcessesState, msg: ProcessesMessage) {
     match msg {
         ProcessesMessage::Refreshed(new) => {
             state.loaded = new.loaded;
             state.processes = new.processes;
             state.power = new.power;
             // The fetch arrives cpu-ordered; a non-default sort re-applies so
             // a refresh never silently flips the list back.
             if state.sort != ProcSort::Cpu {
                 sort_rows(&mut state.processes, state.sort);
             }
             // Fresh list = every pending kill has resolved one way or the
             // other; rows that survived un-dim (the kill didn't take).
             state.killing.clear();
         }
         ProcessesMessage::SortBy(key) => {
             // Clicking the already-active header (Mem, Power, Wakeups)
             // toggles back to the Cpu default; CPU % is always a plain select.
             state.sort = if state.sort == key { ProcSort::Cpu } else { key };
             sort_rows(&mut state.processes, state.sort);
         }
         ProcessesMessage::Kill(pid) => {
             // Plain SIGTERM, same privileges as the app. No confirm dialog:
             // the target is a small `x` glyph the pointer has to mean. Failure needs
             // no channel — a survivor un-dims on the next 3s refresh.
             // Parsed, not passed through: `kill 0` signals the whole process
             // group (this app included), and negative pids kill groups too.
             if pid.parse::<u32>().is_ok_and(|n| n > 0) {
                 let _ = std::process::Command::new("kill").arg(&pid).spawn();
                 state.killing.insert(pid);
             }
         }
         ProcessesMessage::None => {}
     }
 }
 
 impl crate::pages::AppPage for ProcessesState {
     // Sections: [Processes]
     fn section_widgets(&mut self) -> Vec<Vec<cce_ui::widget::WidgetId>> {
         vec![Vec::new()]
     }
 
     fn view(
         &mut self,
         cx: f32,
         cy: f32,
         cw: f32,
         ch: f32,
         root_focused: bool,
         sec_focused: &[bool],
         layout: &mut PageFlow,
         ctx: &mut cce_ui::context::UiContext,
     ) -> crate::app::PageContent {
         view(self, cx, cy, cw, ch, root_focused, sec_focused, layout, ctx)
     }
 
     fn propagate_widget_changes(&mut self, _actions: &mut Vec<crate::app::AppAction>, _ctx: &mut cce_ui::context::UiContext) {}
 
     fn handle_pointer_move(
         &mut self,
         lx: f32,
         ly: f32,
         _actions: &mut Vec<crate::app::AppAction>,
         _ctx: &mut cce_ui::context::UiContext,
     ) -> bool {
         self.loaded && self.cpu_list.cursor_moved(lx, ly)
     }
 
     fn handle_pointer_down(&mut self, lx: f32, ly: f32, _ctx: &mut cce_ui::context::UiContext) -> bool {
         self.loaded && self.cpu_list.press(lx, ly)
     }
 
     fn handle_pointer_up(&mut self, _ctx: &mut cce_ui::context::UiContext) -> bool {
         self.cpu_list.release()
     }
 
     fn handle_mouse_wheel(&mut self, delta: &cce_ui::widget::MouseScrollDelta, lx: f32, ly: f32) -> bool {
         self.loaded && self.cpu_list.wheel(delta, lx, ly)
     }
 
     fn handle_key_input(&mut self, event: &cce_ui::widget::KeyEvent) -> bool {
         self.loaded && self.cpu_list.keyboard(event)
     }
 
     fn tick(&mut self, dt: f32) -> bool {
         self.cpu_list.tick(dt)
     }
 
     fn frameless_lists(&self) -> Vec<&ScrollRegion> {
         vec![&self.cpu_list]
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn test_view_layout_grid() {
         let mut state = ProcessesState::default();
         let mut layout = cce_ui::layout::PageFlow::new();
         let sec_focused = vec![false];
         let mut ctx = cce_ui::context::UiContext::new();
         let pc = view(&mut state, 10.0, 20.0, 800.0, 600.0, false, &sec_focused, &mut layout, &mut ctx);
         assert!(!pc.rects.is_empty() || !pc.texts.is_empty());
     }
 
     #[test]
     fn command_display_prefers_basename_and_keeps_kernel_threads() {
         // Longer than the 15-char comm cap ps used to truncate at.
         assert_eq!(command_display("/home/x/.local/bin/cce-system-interface --flag"), "cce-system-interface");
         assert_eq!(command_display("bash"), "bash");
         assert_eq!(command_display("[kworker/0:1-events]"), "[kworker/0:1-events]");
     }
 
     #[test]
     fn format_rss_humanizes() {
         assert_eq!(format_rss(512), "512 KB");
         assert_eq!(format_rss(4096), "4 MB");
         assert_eq!(format_rss(2_200_000), "2.1 GB");
     }
 
     fn row(pid: &str) -> ProcessRow {
         ProcessRow {
             pid: pid.to_string(),
             cpu: "1.0".to_string(),
             mem_pct: "2.0".to_string(),
             rss_kb: 1024,
             command: "proc".to_string(),
             watts: None,
             wakeups: None,
         }
     }
 
     #[test]
     fn kill_buttons_emitted_after_row_buttons_and_skip_pending() {
         let mut state = ProcessesState { loaded: true, ..Default::default() };
         state.processes = (1..=3).map(|i| row(&i.to_string())).collect();
         state.killing.insert("2".to_string());
         let mut layout = cce_ui::layout::PageFlow::new();
         let sec_focused = vec![false];
         let mut ctx = cce_ui::context::UiContext::new();
         let pc = view(&mut state, 10.0, 20.0, 800.0, 600.0, false, &sec_focused, &mut layout, &mut ctx);
 
         let kills: Vec<usize> = pc
             .buttons
             .iter()
             .enumerate()
             .filter(|(_, (_, a, _))| matches!(a, AppAction::Processes(ProcessesMessage::Kill(_))))
             .map(|(i, _)| i)
             .collect();
         // One Kill button per row except the pending one (pid 2).
         assert_eq!(kills.len(), 2, "{:?}", pc.buttons.iter().map(|(_, a, _)| a).collect::<Vec<_>>());
         // Ordering invariant the dispatch relies on: each Kill comes after
         // its row's hover button — last take_click wins, so Kill must be later.
         let rows: Vec<usize> = pc
             .buttons
             .iter()
             .enumerate()
             .filter(|(_, (_, a, _))| matches!(a, AppAction::Processes(ProcessesMessage::None)))
             .map(|(i, _)| i)
             .collect();
         assert!(kills[0] > rows[0]);
     }
 
     #[test]
     fn kill_guards_and_dim_lifecycle() {
         let mut state = ProcessesState { loaded: true, ..Default::default() };
         // Group-signal and garbage pids are refused outright.
         update(&mut state, ProcessesMessage::Kill("0".to_string()));
         update(&mut state, ProcessesMessage::Kill("-1".to_string()));
         update(&mut state, ProcessesMessage::Kill("abc".to_string()));
         update(&mut state, ProcessesMessage::Kill(String::new()));
         assert!(state.killing.is_empty());
 
         // A real (nonexistent, > pid_max) pid marks the row...
         update(&mut state, ProcessesMessage::Kill("99999999".to_string()));
         assert!(state.killing.contains("99999999"));
 
         // ...and the next refresh clears every pending mark.
         update(
             &mut state,
             ProcessesMessage::Refreshed(ProcessesState { loaded: true, ..Default::default() }),
         );
         assert!(state.killing.is_empty());
     }
 
     fn sized_row(pid: &str, cpu: &str, rss: u64) -> ProcessRow {
         ProcessRow {
             pid: pid.to_string(),
             cpu: cpu.to_string(),
             mem_pct: "0.0".to_string(),
             rss_kb: rss,
             command: "p".to_string(),
             watts: None,
             wakeups: None,
         }
     }
 
     #[test]
     fn sort_toggles_between_mem_and_cpu() {
         let mut state = ProcessesState { loaded: true, ..Default::default() };
         // Fetch order = cpu descending; memory order differs deliberately.
         state.processes = vec![
             sized_row("a", "9.0", 100),
             sized_row("b", "5.0", 900),
             sized_row("c", "1.0", 500),
         ];
         let order = |s: &ProcessesState| s.processes.iter().map(|p| p.pid.clone()).collect::<Vec<_>>();
 
         // Mem header: sort by RSS descending.
         update(&mut state, ProcessesMessage::SortBy(ProcSort::Mem));
         assert_eq!(state.sort, ProcSort::Mem);
         assert_eq!(order(&state), ["b", "c", "a"]);
 
         // Same header again: back to the cpu default, re-sorted (the fetch
         // order is gone from the Vec, so this must actually parse and sort).
         update(&mut state, ProcessesMessage::SortBy(ProcSort::Mem));
         assert_eq!(state.sort, ProcSort::Cpu);
         assert_eq!(order(&state), ["a", "b", "c"]);
 
         // CPU % header while already Cpu: stays Cpu.
         update(&mut state, ProcessesMessage::SortBy(ProcSort::Cpu));
         assert_eq!(state.sort, ProcSort::Cpu);
     }
 
     #[test]
     fn refresh_preserves_active_mem_sort() {
         let mut state = ProcessesState { loaded: true, ..Default::default() };
         update(&mut state, ProcessesMessage::SortBy(ProcSort::Mem));
 
         let fresh = ProcessesState {
             loaded: true,
             processes: vec![sized_row("x", "9.0", 10), sized_row("y", "1.0", 999)],
             ..Default::default()
         };
         update(&mut state, ProcessesMessage::Refreshed(fresh));
         // The cpu-ordered fetch was re-sorted under the surviving Mem key.
         assert_eq!(state.sort, ProcSort::Mem);
         assert_eq!(state.processes[0].pid, "y");
     }
 
     #[test]
     fn header_sort_buttons_emitted() {
         let mut state = ProcessesState { loaded: true, ..Default::default() };
         state.processes = vec![sized_row("1", "1.0", 1)];
         let mut layout = cce_ui::layout::PageFlow::new();
         let sec_focused = vec![false];
         let mut ctx = cce_ui::context::UiContext::new();
         let pc = view(&mut state, 10.0, 20.0, 800.0, 600.0, false, &sec_focused, &mut layout, &mut ctx);
         let sorts: Vec<ProcSort> = pc
             .buttons
             .iter()
             .filter_map(|(_, a, _)| match a {
                 AppAction::Processes(ProcessesMessage::SortBy(k)) => Some(*k),
                 _ => None,
             })
             .collect();
         // MEM + MEM % both toggle Mem; CPU % selects Cpu; then W and WAKE/s.
         assert_eq!(sorts, [ProcSort::Mem, ProcSort::Mem, ProcSort::Cpu, ProcSort::Power, ProcSort::Wakeups]);
         // Active-sort indicator rides the CPU % header by default — as a
         // `chevron-down` glyph after the header text, never a character in it.
         assert!(pc.texts.iter().any(|t| t.0 == "CPU %"));
         assert!(pc.texts.iter().all(|t| !t.0.contains('\u{25bc}')));
         if cce_ui::upload_icon("chevron-down", 18).is_some() {
             let cpu = pc.texts.iter().find(|t| t.0 == "CPU %").unwrap();
             assert_eq!(pc.icons.len(), 1, "one sort chevron");
             assert!(pc.icons[0].x > cpu.2, "the chevron follows the header text");
         }
     }
 
     #[test]
     fn columns_pan_with_horizontal_scroll() {
         let mut state = ProcessesState { loaded: true, ..Default::default() };
         state.processes = (0..3).map(|i| row(&i.to_string())).collect();
         let mut layout = cce_ui::layout::PageFlow::new();
         let sec_focused = vec![false];
         let mut ctx = cce_ui::context::UiContext::new();
 
         // Prefix match: the active sort column carries a " ▾" suffix.
         let header_x = |pc: &crate::app::PageContent, s: &str| {
             pc.texts.iter().find(|t| t.0.starts_with(s)).map(|t| t.2).unwrap()
         };
         let pc0 = view(&mut state, 10.0, 20.0, 500.0, 400.0, false, &sec_focused, &mut layout, &mut ctx);
         let x0 = header_x(&pc0, "MEM %");
         // The columns are wider than the ~500px page, so the list is
         // h-scrollable; pan within its range (the columns are as wide as
         // their content, so the range is the table's, not a fixed figure)
         // and every column shifts left by exactly that.
         assert!(state.cpu_list.h_scroll_active());
         let pan = state.cpu_list.max_scroll_x() / 2.0;
         assert!(pan > 0.0);
         state.cpu_list.scroll_x = pan;
         let pc1 = view(&mut state, 10.0, 20.0, 500.0, 400.0, false, &sec_focused, &mut layout, &mut ctx);
         assert_eq!(header_x(&pc1, "MEM %"), x0 - pan);
         assert_eq!(header_x(&pc1, "CPU %"), header_x(&pc0, "CPU %") - pan);
     }
 
     #[test]
     fn power_sort_puts_unknowns_last_and_toggles_back() {
         let mut state = ProcessesState { loaded: true, ..Default::default() };
         let mut a = sized_row("a", "9.0", 1);
         let mut b = sized_row("b", "5.0", 1);
         let c = sized_row("c", "1.0", 1);
         a.watts = Some(0.2);
         b.watts = Some(1.5);
         state.processes = vec![a, b, c];
         let order = |s: &ProcessesState| s.processes.iter().map(|p| p.pid.clone()).collect::<Vec<_>>();
         update(&mut state, ProcessesMessage::SortBy(ProcSort::Power));
         assert_eq!(order(&state), ["b", "a", "c"]);
         update(&mut state, ProcessesMessage::SortBy(ProcSort::Power));
         assert_eq!(state.sort, ProcSort::Cpu);
         assert_eq!(order(&state), ["a", "b", "c"]);
     }
 
     #[test]
     fn list_lies_inside_the_section_clip() {
         // The list used to sit at `left + 12`, 2 * padding outside the
         // content box the section clips to: the summary lost its first
         // letter and every row's hover wash its left edge.
         let mut state = ProcessesState { loaded: true, ..Default::default() };
         state.processes = (0..40).map(|i| row(&i.to_string())).collect();
         let mut layout = cce_ui::layout::PageFlow::new();
         let mut ctx = cce_ui::context::UiContext::new();
         let pc = view(&mut state, 10.0, 20.0, 820.0, 640.0, false, &[false], &mut layout, &mut ctx);
         for t in &pc.texts {
             if let Some(b) = t.6 {
                 assert!(t.2 >= b[0], "{:?} starts at {} left of its clip {}", t.0, t.2, b[0]);
             }
         }
         for (b, a, clip) in &pc.buttons {
             if let Some(c) = clip {
                 assert!(cce_ui::widget::WidgetHost::base(b).x >= c[0], "{a:?} starts left of its clip");
             }
         }
     }
 
     #[test]
     fn rows_clip_at_their_viewport_not_the_band_below() {
         // The scroll region hands back a row that starts just past its
         // viewport; clipped only at the list's bottom, that row's Kill button
         // stood alone in the reserve band under the last row.
         let mut state = ProcessesState { loaded: true, ..Default::default() };
         state.processes = (0..40).map(|i| row(&i.to_string())).collect();
         let mut layout = cce_ui::layout::PageFlow::new();
         let mut ctx = cce_ui::context::UiContext::new();
         let pc = view(&mut state, 10.0, 20.0, 820.0, 640.0, false, &[false], &mut layout, &mut ctx);
         let rows_bottom = state.cpu_list.viewport_y + state.cpu_list.viewport_h;
         for (_, a, clip) in &pc.buttons {
             if matches!(a, AppAction::Processes(ProcessesMessage::Kill(_))) {
                 let c = clip.expect("rows are clipped");
                 assert_eq!(c[1] + c[3], rows_bottom);
             }
         }
     }
 
     #[test]
     fn watts_and_wakeups_format_with_dashes_for_noise() {
         assert_eq!(format_watts(None), "\u{2014}");
         assert_eq!(format_watts(Some(0.04)), "\u{2014}");
         assert_eq!(format_watts(Some(0.05)), "0.1");
         assert_eq!(format_watts(Some(2.345)), "2.3");
         assert_eq!(format_wakeups(None), "\u{2014}");
         assert_eq!(format_wakeups(Some(0.2)), "\u{2014}");
         assert_eq!(format_wakeups(Some(12.6)), "13");
     }
 
     #[test]
     fn summary_line_states_mode_and_reason() {
         let p = PowerSummary { mode: Mode::Battery, total_w: Some(16.0), floor_w: Some(10.0), attributed_w: 6.0 };
         assert_eq!(
             summary_line(&p),
             "16.0 W total  \u{00b7}  10.0 W baseline  \u{00b7}  6.0 W attributed to processes (estimated from battery draw)"
         );
         assert!(summary_line(&PowerSummary::default()).starts_with("Measuring"));
         let u = PowerSummary { mode: Mode::Unavailable, ..Default::default() };
         assert!(summary_line(&u).contains("wakeups only"));
     }
 
     #[test]
     fn refresh_carries_the_power_summary_and_rows_show_watts() {
         let mut state = ProcessesState { loaded: true, ..Default::default() };
         let mut r = sized_row("7", "1.0", 1);
         r.watts = Some(1.26);
         r.wakeups = Some(40.0);
         let fresh = ProcessesState {
             loaded: true,
             processes: vec![r],
             power: PowerSummary { mode: Mode::Battery, total_w: Some(20.0), floor_w: Some(15.0), attributed_w: 1.26 },
             ..Default::default()
         };
         update(&mut state, ProcessesMessage::Refreshed(fresh));
         assert_eq!(state.power.mode, Mode::Battery);
         let mut layout = cce_ui::layout::PageFlow::new();
         let mut ctx = cce_ui::context::UiContext::new();
         let pc = view(&mut state, 10.0, 20.0, 900.0, 600.0, false, &[false], &mut layout, &mut ctx);
         let all: Vec<&str> = pc.texts.iter().map(|t| t.0.as_str()).collect();
         assert!(pc.texts.iter().any(|t| t.0 == "1.3"), "{all:?}");
         assert!(pc.texts.iter().any(|t| t.0 == "40"));
         assert!(pc.texts.iter().any(|t| t.0.starts_with("20.0 W total")));
     }
 }