use crate::{
collector::RefreshResult,
event,
model::{
ServiceStatus, cpu::CpuTopology, gpu::GpuSnapshot, memory::MemorySnapshot,
ollama::OllamaModel, process::ProcessSnapshot,
},
};
use crossterm::event::{KeyCode, KeyEvent};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Focus {
Cpu,
Workload,
Gpu,
Ollama,
ProcessBrowser,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CpuView {
MatrixTiles,
MicroHeatmap,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ProcessSort {
Cpu,
Memory,
Pid,
Name,
}
pub struct App {
pub cpu: CpuTopology,
pub processes: Vec<ProcessSnapshot>,
pub gpu: ServiceStatus<Vec<GpuSnapshot>>,
pub ollama: ServiceStatus<Vec<OllamaModel>>,
pub memory: MemorySnapshot,
pub focus: Focus,
pub cpu_view: CpuView,
pub process_sort: ProcessSort,
pub selected_process: usize,
pub selected_core: usize,
pub process_browser: bool,
pub diagnostics: bool,
pub show_help: bool,
pub status: Vec<String>,
}
impl Default for App {
fn default() -> Self {
Self {
cpu: CpuTopology::default(),
processes: Vec::new(),
gpu: ServiceStatus::Loading,
ollama: ServiceStatus::Loading,
memory: MemorySnapshot::default(),
focus: Focus::Cpu,
cpu_view: CpuView::MatrixTiles,
process_sort: ProcessSort::Cpu,
selected_process: 0,
selected_core: 0,
process_browser: false,
diagnostics: false,
show_help: false,
status: vec!["Collecting system data…".into()],
}
}
}
impl App {
pub fn apply(&mut self, refresh: RefreshResult) {
let selected_pid = self.processes.get(self.selected_process).map(|p| p.pid);
self.cpu = refresh.cpu;
self.processes = refresh.processes;
self.gpu = refresh.gpu;
self.ollama = refresh.ollama;
self.memory = refresh.memory;
self.status = refresh.errors;
if self.status.is_empty() {
self.status.push("Live".into());
}
self.sort_processes();
self.selected_process = selected_pid
.and_then(|pid| self.processes.iter().position(|process| process.pid == pid))
.unwrap_or_else(|| {
self.selected_process
.min(self.processes.len().saturating_sub(1))
});
self.selected_core = self
.selected_core
.min(self.cpu.cores.len().saturating_sub(1));
}
pub fn handle_key(&mut self, key: KeyEvent) -> bool {
if event::is_quit(key) {
return true;
}
if self.show_help {
if matches!(key.code, KeyCode::Char('?') | KeyCode::Esc) {
self.show_help = false;
}
return false;
}
if self.process_browser {
match key.code {
KeyCode::Char('p') | KeyCode::Esc => {
self.process_browser = false;
self.focus = Focus::Cpu;
}
KeyCode::Down | KeyCode::Char('j') => {
self.selected_process =
(self.selected_process + 1).min(self.processes.len().saturating_sub(1));
}
KeyCode::Up | KeyCode::Char('k') => {
self.selected_process = self.selected_process.saturating_sub(1)
}
KeyCode::Enter => {
self.process_browser = false;
self.focus = Focus::Cpu;
}
_ => {}
}
self.sort_processes();
return false;
}
match key.code {
KeyCode::Tab => {
self.focus = match self.focus {
Focus::Cpu => Focus::Workload,
Focus::Workload => Focus::Gpu,
Focus::Gpu => Focus::Ollama,
Focus::Ollama => Focus::Cpu,
Focus::ProcessBrowser => Focus::Cpu,
}
}
KeyCode::Char('?') => self.show_help = true,
KeyCode::Char('c') => {
self.cpu_view = match self.cpu_view {
CpuView::MatrixTiles => CpuView::MicroHeatmap,
CpuView::MicroHeatmap => CpuView::MatrixTiles,
}
}
KeyCode::Char('p') => {
self.process_browser = true;
self.focus = Focus::ProcessBrowser;
}
KeyCode::Char('d') => self.diagnostics = !self.diagnostics,
KeyCode::Char('s') if self.process_browser => {
self.process_sort = match self.process_sort {
ProcessSort::Cpu => ProcessSort::Memory,
ProcessSort::Memory => ProcessSort::Pid,
ProcessSort::Pid => ProcessSort::Name,
ProcessSort::Name => ProcessSort::Cpu,
}
}
KeyCode::Down | KeyCode::Char('j') if self.focus == Focus::Cpu => {
self.selected_core =
(self.selected_core + 1).min(self.cpu.cores.len().saturating_sub(1));
}
KeyCode::Up | KeyCode::Char('k') if self.focus == Focus::Cpu => {
self.selected_core = self.selected_core.saturating_sub(1);
}
KeyCode::Right if self.focus == Focus::Cpu => {
self.selected_core =
(self.selected_core + 1).min(self.cpu.cores.len().saturating_sub(1));
}
KeyCode::Left if self.focus == Focus::Cpu => {
self.selected_core = self.selected_core.saturating_sub(1)
}
KeyCode::Down | KeyCode::Char('j') if self.focus == Focus::ProcessBrowser => {
self.selected_process =
(self.selected_process + 1).min(self.processes.len().saturating_sub(1))
}
KeyCode::Up | KeyCode::Char('k') if self.focus == Focus::ProcessBrowser => {
self.selected_process = self.selected_process.saturating_sub(1)
}
KeyCode::Enter if self.focus == Focus::Cpu || self.focus == Focus::Workload => {
self.status = vec![format!("Selected core {}", self.selected_core)]
}
KeyCode::Enter if self.focus == Focus::ProcessBrowser => {
self.process_browser = false;
self.focus = Focus::Cpu;
self.status = vec![format!(
"Selected PID {}",
self.processes
.get(self.selected_process)
.map(|p| p.pid)
.unwrap_or_default()
)]
}
_ => {}
}
self.sort_processes();
false
}
fn sort_processes(&mut self) {
match self.process_sort {
ProcessSort::Cpu => self.processes.sort_by(|a, b| {
b.cpu_percent
.unwrap_or_default()
.total_cmp(&a.cpu_percent.unwrap_or_default())
}),
ProcessSort::Memory => self
.processes
.sort_by_key(|p| std::cmp::Reverse(p.rss_bytes)),
ProcessSort::Pid => self.processes.sort_by_key(|p| p.pid),
ProcessSort::Name => self.processes.sort_by_key(|a| a.name.to_lowercase()),
}
}
pub fn selected_process(&self) -> Option<&ProcessSnapshot> {
self.processes.get(self.selected_process)
}
}