zinit_client/

tui.rs

//! Interactive TUI for Zinit service management
//!
//! Provides a full-screen terminal interface with:
//! - Service list with status indicators
//! - Start/stop/restart/delete actions
//! - Live log viewer
//! - Keyboard navigation

use crate::client::ZinitHandle;
use crossterm::{
    event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode, KeyModifiers},
    execute,
    terminal::{EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode},
};
use ratatui::{
    Frame, Terminal,
    backend::CrosstermBackend,
    layout::{Constraint, Direction, Layout, Rect},
    style::{Color, Modifier, Style},
    text::{Line, Span},
    widgets::{Block, Borders, Clear, List, ListItem, ListState, Paragraph, Wrap},
};
use std::io;
use std::time::{Duration, Instant};

/// Service information for display
#[derive(Clone, Debug)]
struct ServiceInfo {
    name: String,
    state: String,
    pid: i32,
    #[allow(dead_code)]
    target: String,
    memory_kb: u64,
    cpu_percent: f32,
    /// Process tree (pid -> (name, children_pids))
    process_tree: Vec<(i32, String, Vec<i32>)>,
}

/// Application state
struct App {
    /// Zinit handle for sync RPC
    handle: ZinitHandle,
    /// List of services
    services: Vec<ServiceInfo>,
    /// Selected service index
    selected: ListState,
    /// Log lines for selected service
    logs: Vec<String>,
    /// Log scroll position
    log_scroll: usize,
    /// Whether to show help popup
    show_help: bool,
    /// Whether to show service detail popup
    show_detail: bool,
    /// Status message
    status_message: Option<(String, Instant)>,
    /// Current focus: Services or Logs
    focus: Focus,
    /// Whether logs are being followed
    following_logs: bool,
}

#[derive(PartialEq, Clone, Copy)]
enum Focus {
    Services,
    Logs,
}

impl App {
    fn new(handle: ZinitHandle) -> Self {
        let mut selected = ListState::default();
        selected.select(Some(0));
        Self {
            handle,
            services: Vec::new(),
            selected,
            logs: Vec::new(),
            log_scroll: 0,
            show_help: false,
            show_detail: false,
            status_message: None,
            focus: Focus::Services,
            following_logs: true,
        }
    }

    fn set_status(&mut self, msg: impl Into<String>) {
        self.status_message = Some((msg.into(), Instant::now()));
    }

    fn selected_service(&self) -> Option<&ServiceInfo> {
        self.selected.selected().and_then(|i| self.services.get(i))
    }

    fn next_service(&mut self) {
        if self.services.is_empty() {
            return;
        }
        let i = match self.selected.selected() {
            Some(i) => {
                if i >= self.services.len() - 1 {
                    0
                } else {
                    i + 1
                }
            }
            None => 0,
        };
        self.selected.select(Some(i));
        self.following_logs = true;
    }

    fn previous_service(&mut self) {
        if self.services.is_empty() {
            return;
        }
        let i = match self.selected.selected() {
            Some(i) => {
                if i == 0 {
                    self.services.len() - 1
                } else {
                    i - 1
                }
            }
            None => 0,
        };
        self.selected.select(Some(i));
        self.following_logs = true;
    }

    fn scroll_logs_up(&mut self) {
        if self.log_scroll > 0 {
            self.log_scroll -= 1;
            self.following_logs = false;
        }
    }

    fn scroll_logs_down(&mut self, visible_height: usize) {
        let max_scroll = self.logs.len().saturating_sub(visible_height);
        if self.log_scroll < max_scroll {
            self.log_scroll += 1;
        }
        if self.log_scroll >= max_scroll {
            self.following_logs = true;
        }
    }

    fn scroll_logs_to_end(&mut self) {
        self.following_logs = true;
    }

    fn toggle_focus(&mut self) {
        self.focus = match self.focus {
            Focus::Services => Focus::Logs,
            Focus::Logs => Focus::Services,
        };
    }

    /// Fetch services from server
    fn fetch_services(&mut self) {
        let mut services = Vec::new();
        if let Ok(names) = self.handle.list() {
            for name in names {
                if let Ok(status) = self.handle.status(&name) {
                    // Convert process tree to display format
                    let process_tree: Vec<(i32, String, Vec<i32>)> = status
                        .process_tree
                        .processes
                        .iter()
                        .map(|(&pid, node)| (pid, node.name.clone(), node.children.clone()))
                        .collect();

                    services.push(ServiceInfo {
                        name: status.name,
                        state: status.state,
                        pid: status.pid,
                        target: status.target,
                        memory_kb: 0,
                        cpu_percent: 0.0,
                        process_tree,
                    });
                }
            }
        }
        services.sort_by(|a, b| a.name.cmp(&b.name));
        self.services = services;
    }

    /// Fetch stats for selected service
    fn fetch_selected_stats(&mut self) {
        if let Some(idx) = self.selected.selected()
            && let Some(service) = self.services.get(idx)
        {
            let name = service.name.clone();
            if let Ok(stats) = self.handle.stats(&name)
                && let Some(s) = self.services.get_mut(idx)
            {
                s.memory_kb = stats.memory_usage / 1024;
                s.cpu_percent = stats.cpu_usage;
            }
        }
    }

    /// Fetch logs for selected service
    fn fetch_logs(&mut self) {
        if let Some(service) = self.selected_service() {
            let name = service.name.clone();
            if let Ok(logs) = self.handle.logs_filter(&name) {
                self.logs = logs;
            }
        }
    }

    /// Execute a service action
    fn start_service(&mut self) {
        if let Some(service) = self.selected_service() {
            let name = service.name.clone();
            match self.handle.start(&name) {
                Ok(_) => self.set_status(format!("Started: {}", name)),
                Err(e) => self.set_status(format!("Error: {}", e)),
            }
            self.fetch_services();
        }
    }

    fn stop_service(&mut self) {
        if let Some(service) = self.selected_service() {
            let name = service.name.clone();
            match self.handle.stop(&name) {
                Ok(_) => self.set_status(format!("Stopped: {}", name)),
                Err(e) => self.set_status(format!("Error: {}", e)),
            }
            self.fetch_services();
        }
    }

    fn restart_service(&mut self) {
        if let Some(service) = self.selected_service() {
            let name = service.name.clone();
            match self.handle.restart(&name) {
                Ok(_) => self.set_status(format!("Restarted: {}", name)),
                Err(e) => self.set_status(format!("Error: {}", e)),
            }
            self.fetch_services();
        }
    }

    fn delete_service(&mut self) {
        if let Some(service) = self.selected_service() {
            let name = service.name.clone();
            match self.handle.delete(&name) {
                Ok(_) => self.set_status(format!("Deleted: {}", name)),
                Err(e) => self.set_status(format!("Error: {}", e)),
            }
            self.fetch_services();
            // Adjust selection if needed
            if let Some(selected) = self.selected.selected()
                && selected >= self.services.len()
                && !self.services.is_empty()
            {
                self.selected.select(Some(self.services.len() - 1));
            }
        }
    }

    fn kill_service(&mut self, signal: &str) {
        if let Some(service) = self.selected_service() {
            let name = service.name.clone();
            let process_count = service.process_tree.len();
            match self.handle.kill(&name, signal) {
                Ok(_) => {
                    if process_count > 1 {
                        self.set_status(format!(
                            "Sent {} to {} ({} processes)",
                            signal, name, process_count
                        ))
                    } else {
                        self.set_status(format!("Sent {} to {}", signal, name))
                    }
                }
                Err(e) => self.set_status(format!("Error: {}", e)),
            }
            self.fetch_services();
        }
    }
}

/// Format service state with color
fn state_color(state: &str) -> Color {
    if state.starts_with("Exited") {
        return Color::Magenta;
    }
    match state.to_lowercase().as_str() {
        "running" => Color::Green,
        "success" => Color::Green,
        "spawned" => Color::Yellow,
        "blocked" => Color::Yellow,
        "stopped" => Color::Red,
        "failed" => Color::Red,
        "testfailed" => Color::Red,
        "exited" => Color::Magenta,
        _ => Color::Gray,
    }
}

fn format_memory(kb: u64) -> String {
    if kb >= 1024 * 1024 {
        format!("{:.1} GB", kb as f64 / (1024.0 * 1024.0))
    } else if kb >= 1024 {
        format!("{:.1} MB", kb as f64 / 1024.0)
    } else {
        format!("{} KB", kb)
    }
}

/// Draw the UI
fn draw(frame: &mut Frame, app: &App) {
    // Create main layout
    let chunks = Layout::default()
        .direction(Direction::Vertical)
        .constraints([
            Constraint::Length(3), // Title
            Constraint::Min(10),   // Main content
            Constraint::Length(3), // Status bar
        ])
        .split(frame.area());

    // Title
    let title = Paragraph::new(Line::from(vec![
        Span::styled(
            "Zinit ",
            Style::default()
                .fg(Color::Cyan)
                .add_modifier(Modifier::BOLD),
        ),
        Span::styled("Interactive Mode", Style::default().fg(Color::White)),
        Span::raw(" | "),
        Span::styled("?", Style::default().fg(Color::Yellow)),
        Span::raw(" Help  "),
        Span::styled("Q", Style::default().fg(Color::Yellow)),
        Span::raw(" Quit"),
    ]))
    .block(
        Block::default()
            .borders(Borders::ALL)
            .border_style(Style::default().fg(Color::Cyan)),
    );
    frame.render_widget(title, chunks[0]);

    // Main content - split into services and logs
    let main_chunks = Layout::default()
        .direction(Direction::Horizontal)
        .constraints([Constraint::Percentage(40), Constraint::Percentage(60)])
        .split(chunks[1]);

    draw_services(frame, app, main_chunks[0]);
    draw_logs(frame, app, main_chunks[1]);

    // Status bar
    let status_text = if let Some((msg, time)) = &app.status_message {
        if time.elapsed() < Duration::from_secs(5) {
            msg.clone()
        } else {
            get_default_status(app)
        }
    } else {
        get_default_status(app)
    };

    let status = Paragraph::new(status_text)
        .style(Style::default().fg(Color::White))
        .block(
            Block::default()
                .borders(Borders::ALL)
                .border_style(Style::default().fg(Color::DarkGray)),
        );
    frame.render_widget(status, chunks[2]);

    // Help popup
    if app.show_help {
        draw_help_popup(frame);
    }

    // Detail popup
    if app.show_detail
        && let Some(service) = app.selected_service()
    {
        draw_detail_popup(frame, service);
    }
}

fn get_default_status(app: &App) -> String {
    let service_info = app
        .selected_service()
        .map(|s| {
            format!(
                "Service: {} | State: {} | PID: {} | Enter: details",
                s.name, s.state, s.pid
            )
        })
        .unwrap_or_else(|| "No service selected".to_string());

    let focus_indicator = match app.focus {
        Focus::Services => "[Services]",
        Focus::Logs => "[Logs]",
    };

    format!("{} | {} | Tab: switch focus", service_info, focus_indicator)
}

fn draw_services(frame: &mut Frame, app: &App, area: Rect) {
    let items: Vec<ListItem> = app
        .services
        .iter()
        .map(|service| {
            let state_style = Style::default().fg(state_color(&service.state));
            let content = Line::from(vec![
                Span::styled(
                    format!("{:2} ", if service.pid > 0 { "●" } else { "○" }),
                    state_style,
                ),
                Span::styled(&service.name, Style::default().fg(Color::White)),
                Span::raw(" "),
                Span::styled(
                    format!("[{}]", &service.state),
                    state_style.add_modifier(Modifier::DIM),
                ),
            ]);
            ListItem::new(content)
        })
        .collect();

    let border_color = if app.focus == Focus::Services {
        Color::Cyan
    } else {
        Color::DarkGray
    };

    let services_list = List::new(items)
        .block(
            Block::default()
                .title(format!(" Services ({}) ", app.services.len()))
                .borders(Borders::ALL)
                .border_style(Style::default().fg(border_color)),
        )
        .highlight_style(
            Style::default()
                .bg(Color::DarkGray)
                .add_modifier(Modifier::BOLD),
        )
        .highlight_symbol("▶ ");

    frame.render_stateful_widget(services_list, area, &mut app.selected.clone());
}

fn draw_logs(frame: &mut Frame, app: &App, area: Rect) {
    let border_color = if app.focus == Focus::Logs {
        Color::Cyan
    } else {
        Color::DarkGray
    };

    let service_name = app
        .selected_service()
        .map(|s| s.name.clone())
        .unwrap_or_else(|| "none".to_string());

    let visible_height = (area.height as usize).saturating_sub(2); // Account for borders
    let total_logs = app.logs.len();

    // Calculate scroll position
    let scroll_offset = if app.following_logs {
        total_logs.saturating_sub(visible_height)
    } else {
        app.log_scroll
            .min(total_logs.saturating_sub(visible_height))
    };

    let visible_logs: Vec<Line> = app
        .logs
        .iter()
        .skip(scroll_offset)
        .take(visible_height)
        .map(|line| {
            // Color the log line based on content
            let style = if line.contains("[+]") {
                Style::default().fg(Color::Green)
            } else if line.contains("[-]") {
                Style::default().fg(Color::Yellow)
            } else if line.contains("error") || line.contains("Error") || line.contains("ERROR") {
                Style::default().fg(Color::Red)
            } else {
                Style::default().fg(Color::Gray)
            };
            Line::from(Span::styled(line.clone(), style))
        })
        .collect();

    let follow_indicator = if app.following_logs {
        " [following]"
    } else {
        ""
    };
    let scroll_info = format!(
        " {}/{} ",
        scroll_offset + visible_height.min(total_logs),
        total_logs
    );

    let logs_widget = Paragraph::new(visible_logs)
        .block(
            Block::default()
                .title(format!(" Logs: {}{} ", service_name, follow_indicator))
                .title_bottom(Line::from(scroll_info).centered())
                .borders(Borders::ALL)
                .border_style(Style::default().fg(border_color)),
        )
        .wrap(Wrap { trim: false });

    frame.render_widget(logs_widget, area);
}

fn draw_help_popup(frame: &mut Frame) {
    let area = frame.area();
    let popup_area = Rect {
        x: area.width / 6,
        y: area.height / 6,
        width: area.width * 2 / 3,
        height: area.height * 2 / 3,
    };

    // Clear the popup area
    frame.render_widget(Clear, popup_area);

    let help_text = vec![
        Line::from(Span::styled(
            "Keyboard Shortcuts",
            Style::default()
                .fg(Color::Cyan)
                .add_modifier(Modifier::BOLD),
        )),
        Line::from(""),
        Line::from(vec![Span::styled(
            "Navigation:",
            Style::default()
                .fg(Color::Yellow)
                .add_modifier(Modifier::BOLD),
        )]),
        Line::from(vec![
            Span::styled("  ↑         ", Style::default().fg(Color::Green)),
            Span::raw("Move up in service list"),
        ]),
        Line::from(vec![
            Span::styled("  ↓/j       ", Style::default().fg(Color::Green)),
            Span::raw("Move down in service list"),
        ]),
        Line::from(vec![
            Span::styled("  Tab       ", Style::default().fg(Color::Green)),
            Span::raw("Switch focus between services and logs"),
        ]),
        Line::from(vec![
            Span::styled("  PgUp/PgDn ", Style::default().fg(Color::Green)),
            Span::raw("Scroll logs"),
        ]),
        Line::from(vec![
            Span::styled("  g/G       ", Style::default().fg(Color::Green)),
            Span::raw("Go to top/bottom of logs"),
        ]),
        Line::from(""),
        Line::from(vec![Span::styled(
            "Actions:",
            Style::default()
                .fg(Color::Yellow)
                .add_modifier(Modifier::BOLD),
        )]),
        Line::from(vec![
            Span::styled("  s         ", Style::default().fg(Color::Green)),
            Span::raw("Start selected service"),
        ]),
        Line::from(vec![
            Span::styled("  x         ", Style::default().fg(Color::Green)),
            Span::raw("Stop selected service (graceful, kills all children)"),
        ]),
        Line::from(vec![
            Span::styled("  r         ", Style::default().fg(Color::Green)),
            Span::raw("Restart selected service"),
        ]),
        Line::from(vec![
            Span::styled("  k         ", Style::default().fg(Color::Green)),
            Span::raw("Kill with SIGTERM (all processes in tree)"),
        ]),
        Line::from(vec![
            Span::styled("  K         ", Style::default().fg(Color::Green)),
            Span::raw("Kill with SIGKILL (force kill all)"),
        ]),
        Line::from(vec![
            Span::styled("  d         ", Style::default().fg(Color::Green)),
            Span::raw("Delete (forget) stopped service"),
        ]),
        Line::from(vec![
            Span::styled("  R         ", Style::default().fg(Color::Green)),
            Span::raw("Refresh service list"),
        ]),
        Line::from(""),
        Line::from(vec![Span::styled(
            "Other:",
            Style::default()
                .fg(Color::Yellow)
                .add_modifier(Modifier::BOLD),
        )]),
        Line::from(vec![
            Span::styled("  ?         ", Style::default().fg(Color::Green)),
            Span::raw("Toggle this help"),
        ]),
        Line::from(vec![
            Span::styled("  Q/Esc     ", Style::default().fg(Color::Green)),
            Span::raw("Quit"),
        ]),
        Line::from(""),
        Line::from(Span::styled(
            "Press any key to close",
            Style::default().fg(Color::DarkGray),
        )),
    ];

    let help = Paragraph::new(help_text)
        .block(
            Block::default()
                .title(" Help ")
                .borders(Borders::ALL)
                .border_style(Style::default().fg(Color::Cyan)),
        )
        .style(Style::default().bg(Color::Black));

    frame.render_widget(help, popup_area);
}

fn draw_detail_popup(frame: &mut Frame, service: &ServiceInfo) {
    let area = frame.area();
    // Make popup larger to fit process tree
    let popup_area = Rect {
        x: area.width / 6,
        y: area.height / 6,
        width: area.width * 2 / 3,
        height: area.height * 2 / 3,
    };

    // Clear the popup area
    frame.render_widget(Clear, popup_area);

    let state_color = state_color(&service.state);
    let mem_str = format_memory(service.memory_kb);

    let mut detail_text = vec![
        Line::from(Span::styled(
            format!(" {} ", service.name),
            Style::default()
                .fg(Color::Cyan)
                .add_modifier(Modifier::BOLD),
        )),
        Line::from(""),
        Line::from(vec![Span::styled(
            "Status",
            Style::default()
                .fg(Color::Yellow)
                .add_modifier(Modifier::BOLD),
        )]),
        Line::from(vec![
            Span::raw("  State:  "),
            Span::styled(
                &service.state,
                Style::default()
                    .fg(state_color)
                    .add_modifier(Modifier::BOLD),
            ),
        ]),
        Line::from(vec![
            Span::raw("  PID:    "),
            Span::styled(
                if service.pid > 0 {
                    service.pid.to_string()
                } else {
                    "-".to_string()
                },
                Style::default().fg(Color::White),
            ),
        ]),
        Line::from(""),
        Line::from(vec![Span::styled(
            "Resource Usage",
            Style::default()
                .fg(Color::Yellow)
                .add_modifier(Modifier::BOLD),
        )]),
        Line::from(vec![
            Span::raw("  CPU:    "),
            Span::styled(
                format!("{:.1}%", service.cpu_percent),
                Style::default().fg(if service.cpu_percent > 80.0 {
                    Color::Red
                } else if service.cpu_percent > 50.0 {
                    Color::Yellow
                } else {
                    Color::Green
                }),
            ),
        ]),
        Line::from(vec![
            Span::raw("  Memory: "),
            Span::styled(
                mem_str,
                Style::default().fg(if service.memory_kb > 1024 * 1024 {
                    Color::Red
                } else if service.memory_kb > 512 * 1024 {
                    Color::Yellow
                } else {
                    Color::Green
                }),
            ),
        ]),
    ];

    // Add process tree section if there are processes
    if !service.process_tree.is_empty() {
        detail_text.push(Line::from(""));
        detail_text.push(Line::from(vec![Span::styled(
            format!("Process Tree ({} processes)", service.process_tree.len()),
            Style::default()
                .fg(Color::Yellow)
                .add_modifier(Modifier::BOLD),
        )]));

        // Sort processes by PID for consistent display
        let mut sorted_procs = service.process_tree.clone();
        sorted_procs.sort_by_key(|(pid, _, _)| *pid);

        for (pid, name, children) in sorted_procs.iter().take(8) {
            // Limit to 8 processes
            let children_str = if children.is_empty() {
                String::new()
            } else {
                format!(" -> {} children", children.len())
            };
            detail_text.push(Line::from(vec![
                Span::styled(format!("  {:6} ", pid), Style::default().fg(Color::Cyan)),
                Span::styled(name.clone(), Style::default().fg(Color::White)),
                Span::styled(children_str, Style::default().fg(Color::DarkGray)),
            ]));
        }

        if service.process_tree.len() > 8 {
            detail_text.push(Line::from(Span::styled(
                format!("  ... and {} more", service.process_tree.len() - 8),
                Style::default().fg(Color::DarkGray),
            )));
        }
    }

    detail_text.push(Line::from(""));
    detail_text.push(Line::from(vec![Span::styled(
        "Actions",
        Style::default()
            .fg(Color::Yellow)
            .add_modifier(Modifier::BOLD),
    )]));
    detail_text.push(Line::from(vec![
        Span::styled(
            "  s ",
            Style::default()
                .fg(Color::Green)
                .add_modifier(Modifier::BOLD),
        ),
        Span::raw("Start    "),
        Span::styled(
            "  k ",
            Style::default().fg(Color::Red).add_modifier(Modifier::BOLD),
        ),
        Span::raw("Kill (SIGTERM)"),
    ]));
    detail_text.push(Line::from(vec![
        Span::styled(
            "  x ",
            Style::default().fg(Color::Red).add_modifier(Modifier::BOLD),
        ),
        Span::raw("Stop     "),
        Span::styled(
            "  K ",
            Style::default().fg(Color::Red).add_modifier(Modifier::BOLD),
        ),
        Span::raw("Kill (SIGKILL)"),
    ]));
    detail_text.push(Line::from(vec![
        Span::styled(
            "  r ",
            Style::default()
                .fg(Color::Yellow)
                .add_modifier(Modifier::BOLD),
        ),
        Span::raw("Restart  "),
        Span::styled(
            "  d ",
            Style::default()
                .fg(Color::Magenta)
                .add_modifier(Modifier::BOLD),
        ),
        Span::raw("Delete"),
    ]));
    detail_text.push(Line::from(""));
    detail_text.push(Line::from(Span::styled(
        "Press Esc to close",
        Style::default().fg(Color::DarkGray),
    )));

    let detail = Paragraph::new(detail_text)
        .block(
            Block::default()
                .title(" Service Details ")
                .borders(Borders::ALL)
                .border_style(Style::default().fg(Color::Cyan)),
        )
        .style(Style::default().bg(Color::Black));

    frame.render_widget(detail, popup_area);
}

/// Run the TUI
pub fn run_tui(handle: ZinitHandle) -> anyhow::Result<()> {
    // Setup terminal
    enable_raw_mode()?;
    let mut stdout = io::stdout();
    execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
    let backend = CrosstermBackend::new(stdout);
    let mut terminal = Terminal::new(backend)?;

    // Create app state
    let mut app = App::new(handle);

    // Initial fetch
    app.fetch_services();
    app.fetch_logs();

    let refresh_interval = Duration::from_secs(2);
    let mut last_refresh = Instant::now();
    let mut needs_redraw = true;

    loop {
        // Only draw when needed
        if needs_redraw {
            terminal.draw(|f| draw(f, &app))?;
            needs_redraw = false;
        }

        // Wait for events with 200ms timeout (allows periodic refresh check)
        let timeout = Duration::from_millis(200);

        if event::poll(timeout)?
            && let Event::Key(key) = event::read()?
        {
            // If help is shown, any key closes it
            if app.show_help {
                app.show_help = false;
                needs_redraw = true;
                continue;
            }

            // Handle detail popup
            if app.show_detail {
                match key.code {
                    KeyCode::Esc | KeyCode::Enter => {
                        app.show_detail = false;
                    }
                    KeyCode::Char('s') => {
                        app.start_service();
                        app.show_detail = false;
                    }
                    KeyCode::Char('x') => {
                        app.stop_service();
                        app.show_detail = false;
                    }
                    KeyCode::Char('r') => {
                        app.restart_service();
                        app.show_detail = false;
                    }
                    KeyCode::Char('d') => {
                        app.delete_service();
                        app.show_detail = false;
                    }
                    KeyCode::Char('k') => {
                        app.kill_service("SIGTERM");
                        app.show_detail = false;
                    }
                    KeyCode::Char('K') => {
                        app.kill_service("SIGKILL");
                        app.show_detail = false;
                    }
                    _ => {}
                }
                needs_redraw = true;
                continue;
            }

            match (key.code, key.modifiers) {
                // Quit
                (KeyCode::Char('Q'), _) | (KeyCode::Esc, _) => break,
                (KeyCode::Char('c'), KeyModifiers::CONTROL) => break,

                // Help
                (KeyCode::Char('?'), _) => app.show_help = true,

                // Open detail popup with stats
                (KeyCode::Enter, _) => {
                    if app.focus == Focus::Services {
                        app.fetch_selected_stats();
                        app.show_detail = true;
                    }
                }

                // Navigation (arrow keys only, k/K reserved for kill)
                (KeyCode::Up, _) => {
                    if app.focus == Focus::Services {
                        app.previous_service();
                    } else {
                        app.scroll_logs_up();
                    }
                }
                (KeyCode::Down, _) | (KeyCode::Char('j'), _) => {
                    if app.focus == Focus::Services {
                        app.next_service();
                    } else {
                        let visible_height = terminal.size()?.height as usize;
                        app.scroll_logs_down(visible_height);
                    }
                }
                (KeyCode::Tab, _) => app.toggle_focus(),

                // Log scrolling
                (KeyCode::PageUp, _) => {
                    for _ in 0..10 {
                        app.scroll_logs_up();
                    }
                }
                (KeyCode::PageDown, _) => {
                    let visible_height = terminal.size()?.height as usize;
                    for _ in 0..10 {
                        app.scroll_logs_down(visible_height);
                    }
                }
                (KeyCode::Char('g'), _) => {
                    app.log_scroll = 0;
                    app.following_logs = false;
                }
                (KeyCode::Char('G'), _) => {
                    app.scroll_logs_to_end();
                }

                // Actions
                (KeyCode::Char('s'), KeyModifiers::NONE) => {
                    app.start_service();
                }
                (KeyCode::Char('x'), KeyModifiers::NONE) => {
                    app.stop_service();
                }
                (KeyCode::Char('r'), KeyModifiers::NONE) => {
                    app.restart_service();
                }
                (KeyCode::Char('d'), _) => {
                    app.delete_service();
                }
                (KeyCode::Char('k'), KeyModifiers::NONE) => {
                    app.kill_service("SIGTERM");
                }
                (KeyCode::Char('K'), KeyModifiers::SHIFT) => {
                    app.kill_service("SIGKILL");
                }
                (KeyCode::Char('R'), _) => {
                    app.fetch_services();
                    app.fetch_logs();
                    app.set_status("Refreshed");
                }

                _ => {}
            }
            needs_redraw = true;
        }

        // Auto-refresh services and logs
        if last_refresh.elapsed() >= refresh_interval {
            last_refresh = Instant::now();
            app.fetch_services();
            app.fetch_logs();
            needs_redraw = true;
        }
    }

    // Restore terminal
    disable_raw_mode()?;
    execute!(
        terminal.backend_mut(),
        LeaveAlternateScreen,
        DisableMouseCapture
    )?;
    terminal.show_cursor()?;

    Ok(())
}