//! Terminal UI dashboard for actor observatory (RUCHY-0817)

//!

//! Provides a real-time terminal interface for monitoring actor systems,

//! displaying message traces, system metrics, and deadlock information.

#[cfg(test)]

mod tests {

    use super::*;

    use crate::runtime::actor::{ActorSystem, ActorId};

    use crate::runtime::actor::Message;

    use crate::runtime::observatory::{

        ActorObservatory, ObservatoryConfig, MessageTrace, MessageStatus,

        ActorSnapshot, ActorState, MessageStats,

    };

    use std::sync::{Arc, Mutex};

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

    // Helper functions for consistent test setup

    fn create_test_actor_system() -> Arc<Mutex<ActorSystem>> {

        ActorSystem::new()

    }

    fn create_test_observatory() -> Arc<Mutex<ActorObservatory>> {

        let system = create_test_actor_system();

        let config = ObservatoryConfig::default();

        Arc::new(Mutex::new(ActorObservatory::new(system, config)))

    }

    fn create_test_config() -> DashboardConfig {

        DashboardConfig {

            refresh_interval_ms: 500,

            max_traces_display: 10,

            max_actors_display: 5,

            enable_colors: false, // Disable for testing

            show_actor_details: true,

            show_timing_info: true,

            auto_refresh: false, // Disable auto-refresh for tests

        }

    }

    fn create_test_dashboard() -> ObservatoryDashboard {

        let observatory = create_test_observatory();

        let config = create_test_config();

        ObservatoryDashboard::new(observatory, config)

    }

    fn create_test_message_trace() -> MessageTrace {

        MessageTrace {

            trace_id: 1001,

            timestamp: 1000,

            source: Some(ActorId(1)),

            destination: ActorId(2),

            message: Message::User("test_msg".to_string(), vec![]),

            status: MessageStatus::Completed,

            processing_duration_us: Some(1500),

            error: None,

            stack_depth: 1,

            correlation_id: Some("test-corr-id".to_string()),

        }

    }

    fn create_test_actor_snapshot() -> ActorSnapshot {

        ActorSnapshot {

            actor_id: ActorId(1),

            name: "test_actor".to_string(),

            timestamp: 1000,

            state: ActorState::Running,

            mailbox_size: 3,

            parent: Some(ActorId(0)),

            children: vec![ActorId(2)],

            message_stats: MessageStats::default(),

            memory_usage: Some(2048),

        }

    }

    // ========== DashboardConfig Tests ==========

    #[test]

    fn test_dashboard_config_default() {

        let config = DashboardConfig::default();

        assert_eq!(config.refresh_interval_ms, 1000);

        assert_eq!(config.max_traces_display, 50);

        assert_eq!(config.max_actors_display, 20);

        assert!(config.enable_colors);

        assert!(config.show_actor_details);

        assert!(config.show_timing_info);

        assert!(config.auto_refresh);

    }

    #[test]

    fn test_dashboard_config_clone() {

        let config1 = create_test_config();

        let config2 = config1.clone();

        assert_eq!(config1.refresh_interval_ms, config2.refresh_interval_ms);

        assert_eq!(config1.enable_colors, config2.enable_colors);

        assert_eq!(config1.auto_refresh, config2.auto_refresh);

    }

    #[test]

    fn test_dashboard_config_debug() {

        let config = create_test_config();

        let debug_str = format!("{config:?}");

        assert!(debug_str.contains("DashboardConfig"));

        assert!(debug_str.contains("refresh_interval_ms"));

        assert!(debug_str.contains("enable_colors"));

    }

    #[test]

    fn test_dashboard_config_custom_values() {

        let config = DashboardConfig {

            refresh_interval_ms: 2000,

            max_traces_display: 100,

            max_actors_display: 50,

            enable_colors: false,

            show_actor_details: false,

            show_timing_info: false,

            auto_refresh: false,

        };

        assert_eq!(config.refresh_interval_ms, 2000);

        assert_eq!(config.max_traces_display, 100);

        assert!(!config.enable_colors);

        assert!(!config.auto_refresh);

    }

    // ========== DisplayMode Tests ==========

    #[test]

    fn test_display_mode_variants() {

        let modes = [DisplayMode::Overview,

            DisplayMode::ActorList,

            DisplayMode::MessageTraces,

            DisplayMode::Metrics,

            DisplayMode::Deadlocks,

            DisplayMode::Help];

        assert_eq!(modes.len(), 6);

        assert_eq!(modes[0], DisplayMode::Overview);

        assert_ne!(modes[0], DisplayMode::ActorList);

    }

    #[test]

    fn test_display_mode_equality() {

        assert_eq!(DisplayMode::Overview, DisplayMode::Overview);

        assert_ne!(DisplayMode::Overview, DisplayMode::Help);

    }

    #[test]

    fn test_display_mode_clone() {

        let mode1 = DisplayMode::MessageTraces;

        let mode2 = mode1;

        assert_eq!(mode1, mode2);

    }

    #[test]

    fn test_display_mode_copy() {

        let mode1 = DisplayMode::Metrics;

        let mode2 = mode1; // Copy semantics

        assert_eq!(mode1, mode2);

    }

    #[test]

    fn test_display_mode_hash() {

        use std::collections::HashMap;

        let mut map = HashMap::new();

        map.insert(DisplayMode::Overview, "overview");

        map.insert(DisplayMode::Deadlocks, "deadlocks");

        assert_eq!(map.get(&DisplayMode::Overview), Some(&"overview"));

        assert_eq!(map.get(&DisplayMode::Deadlocks), Some(&"deadlocks"));

    }

    #[test]

    fn test_display_mode_debug() {

        let mode = DisplayMode::ActorList;

        let debug_str = format!("{mode:?}");

        assert!(debug_str.contains("ActorList"));

    }

    // ========== Colors Tests ==========

    #[test]

    fn test_colors_with_colors_enabled() {

        let colors = Colors::new(true);

        assert_eq!(colors.reset, "\x1b[0m");

        assert_eq!(colors.bold, "\x1b[1m");

        assert_eq!(colors.red, "\x1b[31m");

        assert_eq!(colors.green, "\x1b[32m");

        assert_eq!(colors.yellow, "\x1b[33m");

        assert_eq!(colors.blue, "\x1b[34m");

        assert_eq!(colors.magenta, "\x1b[35m");

        assert_eq!(colors.cyan, "\x1b[36m");

        assert_eq!(colors.white, "\x1b[37m");

        assert_eq!(colors.gray, "\x1b[90m");

    }

    #[test]

    fn test_colors_with_colors_disabled() {

        let colors = Colors::new(false);

        assert_eq!(colors.reset, "");

        assert_eq!(colors.bold, "");

        assert_eq!(colors.red, "");

        assert_eq!(colors.green, "");

        assert_eq!(colors.yellow, "");

        assert_eq!(colors.blue, "");

        assert_eq!(colors.magenta, "");

        assert_eq!(colors.cyan, "");

        assert_eq!(colors.white, "");

        assert_eq!(colors.gray, "");

    }

    #[test]

    fn test_colors_const_fn() {

        const COLORS_ENABLED: Colors = Colors::new(true);

        assert_eq!(COLORS_ENABLED.red, "\x1b[31m");

        const COLORS_DISABLED: Colors = Colors::new(false);

        assert_eq!(COLORS_DISABLED.red, "");

    }

    // ========== ObservatoryDashboard Creation Tests ==========

    #[test]

    fn test_dashboard_creation() {

        let observatory = create_test_observatory();

        let config = create_test_config();

        let dashboard = ObservatoryDashboard::new(observatory, config.clone());

        assert_eq!(dashboard.display_mode, DisplayMode::Overview);

        assert_eq!(dashboard.config.refresh_interval_ms, config.refresh_interval_ms);

        assert_eq!(dashboard.terminal_size, (80, 24));

        assert!(dashboard.scroll_positions.is_empty());

    }

    #[test]

    fn test_dashboard_with_default_config() {

        let observatory = create_test_observatory();

        let config = DashboardConfig::default();

        let dashboard = ObservatoryDashboard::new(observatory, config);

        assert_eq!(dashboard.config.refresh_interval_ms, 1000);

        assert!(dashboard.config.enable_colors);

        assert!(dashboard.config.auto_refresh);

    }

    #[test]

    fn test_dashboard_last_update_timing() {

        let dashboard = create_test_dashboard();

        let now = Instant::now();

        assert!(now.duration_since(dashboard.last_update) < Duration::from_secs(1));

    }

    // ========== Display Mode Management Tests ==========

    #[test]

    fn test_set_display_mode() {

        let mut dashboard = create_test_dashboard();

        assert_eq!(dashboard.display_mode, DisplayMode::Overview);

        dashboard.set_display_mode(DisplayMode::ActorList);

        assert_eq!(dashboard.display_mode, DisplayMode::ActorList);

        dashboard.set_display_mode(DisplayMode::MessageTraces);

        assert_eq!(dashboard.display_mode, DisplayMode::MessageTraces);

    }

    #[test]

    fn test_get_display_mode() {

        let dashboard = create_test_dashboard();

        assert_eq!(dashboard.get_display_mode(), DisplayMode::Overview);

    }

    #[test]

    fn test_cycle_display_mode() {

        let mut dashboard = create_test_dashboard();

        // Cycle through all modes

        dashboard.cycle_display_mode();

        assert_eq!(dashboard.display_mode, DisplayMode::ActorList);

        dashboard.cycle_display_mode();

        assert_eq!(dashboard.display_mode, DisplayMode::MessageTraces);

        dashboard.cycle_display_mode();

        assert_eq!(dashboard.display_mode, DisplayMode::Metrics);

        dashboard.cycle_display_mode();

        assert_eq!(dashboard.display_mode, DisplayMode::Deadlocks);

        dashboard.cycle_display_mode();

        assert_eq!(dashboard.display_mode, DisplayMode::Help);

        // Should cycle back to Overview

        dashboard.cycle_display_mode();

        assert_eq!(dashboard.display_mode, DisplayMode::Overview);

    }

    // ========== Terminal Size Tests ==========

    #[test]

    fn test_terminal_size_default() {

        let dashboard = create_test_dashboard();

        assert_eq!(dashboard.terminal_size, (80, 24));

    }

    #[test]

    fn test_set_terminal_size() {

        let mut dashboard = create_test_dashboard();

        dashboard.set_terminal_size(120, 40);

        assert_eq!(dashboard.terminal_size, (120, 40));

    }

    #[test]

    fn test_update_terminal_size() {

        let mut dashboard = create_test_dashboard();

        let result = dashboard.update_terminal_size();

        assert!(result.is_ok());

        // Size may or may not change depending on actual terminal

        assert!(dashboard.terminal_size.0 > 0);

        assert!(dashboard.terminal_size.1 > 0);

    }

    // ========== Scroll Position Tests ==========

    #[test]

    fn test_scroll_positions_empty_initially() {

        let dashboard = create_test_dashboard();

        assert!(dashboard.scroll_positions.is_empty());

    }

    #[test]

    fn test_set_scroll_position() {

        let mut dashboard = create_test_dashboard();

        dashboard.set_scroll_position(DisplayMode::MessageTraces, 10);

        assert_eq!(dashboard.get_scroll_position(DisplayMode::MessageTraces), 10);

    }

    #[test]

    fn test_get_scroll_position_default() {

        let dashboard = create_test_dashboard();

        assert_eq!(dashboard.get_scroll_position(DisplayMode::ActorList), 0);

    }

    #[test]

    fn test_multiple_scroll_positions() {

        let mut dashboard = create_test_dashboard();

        dashboard.set_scroll_position(DisplayMode::MessageTraces, 5);

        dashboard.set_scroll_position(DisplayMode::ActorList, 10);

        dashboard.set_scroll_position(DisplayMode::Metrics, 15);

        assert_eq!(dashboard.get_scroll_position(DisplayMode::MessageTraces), 5);

        assert_eq!(dashboard.get_scroll_position(DisplayMode::ActorList), 10);

        assert_eq!(dashboard.get_scroll_position(DisplayMode::Metrics), 15);

    }

    // ========== Color Formatting Tests ==========

    #[test]

    fn test_format_with_color() {

        let dashboard = create_test_dashboard();

        let colors = Colors::new(false); // No colors for testing

        let text = dashboard.format_with_color("test", colors.red);

        assert_eq!(text, "test"); // No color codes when disabled

    }

    #[test]

    fn test_format_actor_state_color() {

        let dashboard = create_test_dashboard();

        let running_color = dashboard.get_actor_state_color(ActorState::Running);

        let failed_color = dashboard.get_actor_state_color(ActorState::Failed("error".to_string()));

        let stopped_color = dashboard.get_actor_state_color(ActorState::Stopped);

        // Colors should be different for different states

        assert_ne!(running_color, failed_color);

        assert_ne!(running_color, stopped_color);

    }

    #[test]

    fn test_format_message_status_color() {

        let dashboard = create_test_dashboard();

        let completed_color = dashboard.get_message_status_color(MessageStatus::Completed);

        let failed_color = dashboard.get_message_status_color(MessageStatus::Failed);

        let processing_color = dashboard.get_message_status_color(MessageStatus::Processing);

        // Colors should be different for different statuses

        assert_ne!(completed_color, failed_color);

        assert_ne!(completed_color, processing_color);

    }

    // ========== Data Formatting Tests ==========

    #[test]

    fn test_format_duration() {

        let dashboard = create_test_dashboard();

        assert_eq!(dashboard.format_duration_us(500), "500μs");

        assert_eq!(dashboard.format_duration_us(1500), "1.5ms");

        assert_eq!(dashboard.format_duration_us(1_000_000), "1.0s");

        assert_eq!(dashboard.format_duration_us(65_000_000), "1m 5s");

    }

    #[test]

    fn test_format_bytes() {

        let dashboard = create_test_dashboard();

        assert_eq!(dashboard.format_bytes(512), "512 B");

        assert_eq!(dashboard.format_bytes(1536), "1.5 KB");

        assert_eq!(dashboard.format_bytes(1_048_576), "1.0 MB");

        assert_eq!(dashboard.format_bytes(1_073_741_824), "1.0 GB");

    }

    #[test]

    fn test_format_timestamp() {

        let dashboard = create_test_dashboard();

        let timestamp = 1_234_567_890;

        let formatted = dashboard.format_timestamp(timestamp);

        // Should return a formatted string

        assert!(!formatted.is_empty());

        assert!(formatted.contains(':')); // Should have time separator

    }

    #[test]

    fn test_truncate_string() {

        let dashboard = create_test_dashboard();

        assert_eq!(dashboard.truncate_string("hello", 10), "hello");

        assert_eq!(dashboard.truncate_string("hello world", 8), "hello...");

        assert_eq!(dashboard.truncate_string("test", 2), "..");

    }

    // ========== Rendering Helper Tests ==========

    #[test]

    fn test_render_header() {

        let dashboard = create_test_dashboard();

        let header = dashboard.render_header("Test Header");

        assert!(header.contains("Test Header"));

        assert!(header.len() > 11); // Should have decoration

    }

    #[test]

    fn test_render_separator() {

        let dashboard = create_test_dashboard();

        let separator = dashboard.render_separator();

        assert!(separator.contains('-'));

        assert!(separator.len() >= 10);

    }

    #[test]

    fn test_render_table_row() {

        let dashboard = create_test_dashboard();

        let row = dashboard.render_table_row(vec!["Col1", "Col2", "Col3"]);

        assert!(row.contains("Col1"));

        assert!(row.contains("Col2"));

        assert!(row.contains("Col3"));

    }

    #[test]

    fn test_render_progress_bar() {

        let dashboard = create_test_dashboard();

        let bar1 = dashboard.render_progress_bar(50, 100, 20);

        assert!(bar1.contains("50%"));

        let bar2 = dashboard.render_progress_bar(75, 100, 20);

        assert!(bar2.contains("75%"));

        let bar3 = dashboard.render_progress_bar(100, 100, 20);

        assert!(bar3.contains("100%"));

    }

    // ========== Key Handling Tests ==========

    #[test]

    fn test_handle_key_quit() {

        let mut dashboard = create_test_dashboard();

        let should_quit = dashboard.handle_key('q');

        assert!(should_quit);

        let should_quit = dashboard.handle_key('Q');

        assert!(should_quit);

    }

    #[test]

    fn test_handle_key_navigation() {

        let mut dashboard = create_test_dashboard();

        // Test mode switching

        dashboard.handle_key('1');

        assert_eq!(dashboard.display_mode, DisplayMode::Overview);

        dashboard.handle_key('2');

        assert_eq!(dashboard.display_mode, DisplayMode::ActorList);

        dashboard.handle_key('3');

        assert_eq!(dashboard.display_mode, DisplayMode::MessageTraces);

        dashboard.handle_key('4');

        assert_eq!(dashboard.display_mode, DisplayMode::Metrics);

        dashboard.handle_key('5');

        assert_eq!(dashboard.display_mode, DisplayMode::Deadlocks);

        dashboard.handle_key('h');

        assert_eq!(dashboard.display_mode, DisplayMode::Help);

    }

    #[test]

    fn test_handle_key_refresh() {

        let mut dashboard = create_test_dashboard();

        let initial_time = dashboard.last_update;

        std::thread::sleep(Duration::from_millis(10));

        dashboard.handle_key('r'); // Refresh

        assert!(dashboard.last_update > initial_time);

    }

    #[test]

    fn test_handle_key_unknown() {

        let mut dashboard = create_test_dashboard();

        let initial_mode = dashboard.display_mode;

        dashboard.handle_key('x'); // Unknown key

        assert_eq!(dashboard.display_mode, initial_mode); // Should not change

    }

    // ========== Integration Tests ==========

    #[test]

    fn test_dashboard_with_populated_observatory() {

        let observatory = create_test_observatory();

        // Add some test data - need to use an empty filter for trace to be accepted

        {

            let obs = observatory.lock().unwrap();

            // Clear any filters that might block the trace

            let trace = create_test_message_trace();

            obs.trace_message(trace).unwrap();

            let snapshot = create_test_actor_snapshot();

            obs.update_actor_snapshot(snapshot).unwrap();

        }

        let config = create_test_config();

        let _dashboard = ObservatoryDashboard::new(observatory.clone(), config);

        // Verify dashboard can access observatory data

        // The trace may not be stored if filters are applied, so just check the call works

        let obs = observatory.lock().unwrap();

        let _traces = obs.get_traces(Some(10), None).unwrap();

        // At minimum, test that the method is callable without panic

    }

    #[test]

    fn test_dashboard_mode_transitions() {

        let mut dashboard = create_test_dashboard();

        // Test all mode transitions

        let modes = vec![

            DisplayMode::Overview,

            DisplayMode::ActorList,

            DisplayMode::MessageTraces,

            DisplayMode::Metrics,

            DisplayMode::Deadlocks,

            DisplayMode::Help,

        ];

        for mode in modes {

            dashboard.set_display_mode(mode);

            assert_eq!(dashboard.get_display_mode(), mode);

        }

    }

    #[test]

    fn test_dashboard_config_changes() {

        let mut dashboard = create_test_dashboard();

        // Change configuration

        dashboard.config.enable_colors = true;

        dashboard.config.auto_refresh = true;

        dashboard.config.refresh_interval_ms = 2000;

        assert!(dashboard.config.enable_colors);

        assert!(dashboard.config.auto_refresh);

        assert_eq!(dashboard.config.refresh_interval_ms, 2000);

    }

    #[test]

    fn test_dashboard_concurrent_access() {

        use std::thread;

        let observatory = Arc::new(Mutex::new(ActorObservatory::new(

            create_test_actor_system(),

            ObservatoryConfig::default()

        )));

        let config = create_test_config();

        let dashboard = Arc::new(Mutex::new(ObservatoryDashboard::new(

            observatory,

            config

        )));

        let mut handles = vec![];

        // Spawn threads to access dashboard concurrently

        for i in 0..3 {

            let dash = dashboard.clone();

            let handle = thread::spawn(move || {

                let mut d = dash.lock().unwrap();

                d.set_scroll_position(DisplayMode::MessageTraces, i);

            });

            handles.push(handle);

        }

        // Wait for all threads

        for handle in handles {

            handle.join().unwrap();

        }

        // Check final state

        let d = dashboard.lock().unwrap();

        assert!(d.scroll_positions.contains_key(&DisplayMode::MessageTraces));

    }

}

use crate::runtime::observatory::{

    ActorObservatory, ActorState, MessageStatus,

};

use anyhow::Result;

use std::collections::HashMap;

use std::io::{self, Write};

use std::sync::{Arc, Mutex};

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

/// Terminal UI dashboard for actor system monitoring

pub struct ObservatoryDashboard {

    /// Reference to the observatory

    observatory: Arc<Mutex<ActorObservatory>>,

    /// Dashboard configuration

    config: DashboardConfig,

    /// Current display mode

    display_mode: DisplayMode,

    /// Last update time

    last_update: Instant,

    /// Terminal dimensions

    terminal_size: (u16, u16), // (width, height)

    /// Scroll positions for different views

    #[allow(dead_code)] // Future feature for scrolling

    scroll_positions: HashMap<DisplayMode, usize>,

}

/// Configuration for the dashboard display

#[derive(Debug, Clone)]

pub struct DashboardConfig {

    /// Refresh interval in milliseconds

    pub refresh_interval_ms: u64,

    /// Maximum number of traces to display

    pub max_traces_display: usize,

    /// Maximum number of actors to display in actor list

    pub max_actors_display: usize,

    /// Enable color output

    pub enable_colors: bool,

    /// Show detailed actor information

    pub show_actor_details: bool,

    /// Show message processing times

    pub show_timing_info: bool,

    /// Auto-refresh the display

    pub auto_refresh: bool,

}

impl Default for DashboardConfig {

    fn default() -> Self {

        Self {

            refresh_interval_ms: 1000, // 1 second

            max_traces_display: 50,

            max_actors_display: 20,

            enable_colors: true,

            show_actor_details: true,

            show_timing_info: true,

            auto_refresh: true,

        }

    }

}

/// Different display modes for the dashboard

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

pub enum DisplayMode {

    /// Overview of the entire system

    Overview,

    /// Actor list with detailed information

    ActorList,

    /// Message trace view

    MessageTraces,

    /// System metrics and performance

    Metrics,

    /// Deadlock detection and analysis

    Deadlocks,

    /// Help screen

    Help,

}

/// Color codes for terminal output

pub struct Colors {

    pub reset: &'static str,

    pub bold: &'static str,

    pub red: &'static str,

    pub green: &'static str,

    pub yellow: &'static str,

    pub blue: &'static str,

    pub magenta: &'static str,

    pub cyan: &'static str,

    pub white: &'static str,

    pub gray: &'static str,

}

impl Colors {

    pub const fn new(enable_colors: bool) -> Self {

        if enable_colors {

            Self {

                reset: "\x1b[0m",

                bold: "\x1b[1m",

                red: "\x1b[31m",

                green: "\x1b[32m",

                yellow: "\x1b[33m",

                blue: "\x1b[34m",

                magenta: "\x1b[35m",

                cyan: "\x1b[36m",

                white: "\x1b[37m",

                gray: "\x1b[90m",

            }

        } else {

            Self {

                reset: "",

                bold: "",

                red: "",

                green: "",

                yellow: "",

                blue: "",

                magenta: "",

                cyan: "",

                white: "",

                gray: "",

            }

        }

    }

}

impl ObservatoryDashboard {

    /// Create a new dashboard

    pub fn new(observatory: Arc<Mutex<ActorObservatory>>, config: DashboardConfig) -> Self {

        Self {

            observatory,

            config,

            display_mode: DisplayMode::Overview,

            last_update: Instant::now(),

            terminal_size: (80, 24), // Default size

            scroll_positions: HashMap::new(),

        }

    }

    /// Start the interactive dashboard

    pub fn start_interactive(&mut self) -> Result<()> {

        // Clear screen and hide cursor

        print!("\x1b[2J\x1b[?25l");

        io::stdout().flush()?;

        loop {

            self.update_terminal_size()?;

            self.render_current_view()?;

            if self.config.auto_refresh {

                // In a real implementation, we would handle keyboard input here

                // For now, just refresh after the interval

                std::thread::sleep(Duration::from_millis(self.config.refresh_interval_ms));

            } else {

                // Wait for user input

                break;

            }

        }

        // Restore cursor and clear screen

        print!("\x1b[?25h\x1b[2J\x1b[H");

        io::stdout().flush()?;

        Ok(())

    }

    /// Render the current view to the terminal

    pub fn render_current_view(&mut self) -> Result<()> {

        // Clear screen and move to top

        print!("\x1b[2J\x1b[H");

        match self.display_mode {

            DisplayMode::Overview => self.render_overview(),

            DisplayMode::ActorList => self.render_actor_list(),

            DisplayMode::MessageTraces => self.render_message_traces(),

            DisplayMode::Metrics => self.render_metrics(),

            DisplayMode::Deadlocks => self.render_deadlocks(),

            DisplayMode::Help => self.render_help(),

        }?;

        // Render status bar at bottom

        self.render_status_bar()?;

        io::stdout().flush()?;

        self.last_update = Instant::now();

        Ok(())

    }

    /// Render the overview screen

    fn render_overview(&self) -> Result<()> {

        let colors = Colors::new(self.config.enable_colors);

        println!("{}{}Ruchy Actor Observatory - System Overview{}", 

                 colors.bold, colors.cyan, colors.reset);

        println!("{}", "─".repeat(self.terminal_size.0 as usize));

        // Get system metrics

        let observatory = self.observatory.lock()

            .map_err(|_| anyhow::anyhow!("Failed to acquire observatory lock"))?;

        let metrics = observatory.get_metrics()?;

        let snapshots = observatory.get_actor_snapshots()?;

        let recent_traces = observatory.get_traces(Some(10), None)?;

        let deadlocks = observatory.detect_deadlocks()?;

        // System status summary

        println!("{}System Status:{}", colors.bold, colors.reset);

        println!("  Active Actors: {}{}{}", colors.green, metrics.active_actors, colors.reset);

        println!("  Messages Processed: {}{}{}", colors.blue, metrics.total_messages_processed, colors.reset);

        println!("  Messages/sec: {}{:.2}{}", colors.yellow, metrics.system_messages_per_second, colors.reset);

        println!("  Avg Mailbox Size: {}{:.1}{}", colors.cyan, metrics.avg_mailbox_size, colors.reset);

        if !deadlocks.is_empty() {

            println!("  {}Deadlocks Detected: {}{}{}", 

                     colors.red, colors.bold, deadlocks.len(), colors.reset);

        }

        println!();

        // Actor states summary

        println!("{}Actor States:{}", colors.bold, colors.reset);

        let mut state_counts = HashMap::new();

        for snapshot in snapshots.values() {

            *state_counts.entry(&snapshot.state).or_insert(0) += 1;

        }

        for (state, count) in &state_counts {

            let state_color = match state {

                ActorState::Running => colors.green,

                ActorState::Processing(_) => colors.yellow,

                ActorState::Failed(_) => colors.red,

                ActorState::Restarting => colors.magenta,

                _ => colors.gray,

            };

            println!("  {}: {}{}{}", state_display(state), state_color, count, colors.reset);

        }

        println!();

        // Recent message activity

        println!("{}Recent Messages:{}", colors.bold, colors.reset);

        if recent_traces.is_empty() {

            println!("  No recent messages");

        } else {

            for trace in recent_traces.iter().take(5) {

                let status_color = match trace.status {

                    MessageStatus::Completed => colors.green,

                    MessageStatus::Failed => colors.red,

                    MessageStatus::Processing => colors.yellow,

                    _ => colors.gray,

                };

                let duration_str = if let Some(duration) = trace.processing_duration_us {

                    format!(" ({duration}µs)")

                } else {

                    String::new()

                };

                println!("  {} → {}: {}{:?}{}{}", 

                         trace.source.map_or("external".to_string(), |id| id.to_string()),

                         trace.destination,

                         status_color,

                         trace.status,

                         colors.reset,

                         duration_str);

            }

        }

        Ok(())

    }

    /// Render the actor list view

    fn render_actor_list(&self) -> Result<()> {

        let colors = Colors::new(self.config.enable_colors);

        println!("{}{}Ruchy Actor Observatory - Actor List{}", 

                 colors.bold, colors.cyan, colors.reset);

        println!("{}", "─".repeat(self.terminal_size.0 as usize));

        let observatory = self.observatory.lock()

            .map_err(|_| anyhow::anyhow!("Failed to acquire observatory lock"))?;

        let snapshots = observatory.get_actor_snapshots()?;

        if snapshots.is_empty() {

            println!("No active actors");

            return Ok(());

        }

        // Table headers

        println!("{}ID        Name            State       Mailbox  Messages  Avg Time{}", 

                 colors.bold, colors.reset);

        println!("{}", "─".repeat(self.terminal_size.0 as usize));

        // Sort actors by ID for consistent display

        let mut sorted_snapshots: Vec<_> = snapshots.values().collect();

        sorted_snapshots.sort_by_key(|s| s.actor_id.0);

        for snapshot in sorted_snapshots.iter().take(self.config.max_actors_display) {

            let state_color = match snapshot.state {

                ActorState::Running => colors.green,

                ActorState::Processing(_) => colors.yellow,

                ActorState::Failed(_) => colors.red,

                ActorState::Restarting => colors.magenta,

                _ => colors.gray,

            };

            let state_display = match &snapshot.state {

                ActorState::Processing(msg_type) => format!("Proc({msg_type})"),

                ActorState::Failed(reason) => format!("Failed({reason})"),

                other => state_display(other),

            };

            println!("{:<9} {:<15} {}{:<11}{} {:<8} {:<9} {:.1}µs",

                     snapshot.actor_id,

                     snapshot.name,

                     state_color,

                     state_display,

                     colors.reset,

                     snapshot.mailbox_size,

                     snapshot.message_stats.total_processed,

                     snapshot.message_stats.avg_processing_time_us);

        }

        Ok(())

    }

    /// Render the message traces view

    fn render_message_traces(&self) -> Result<()> {

        let colors = Colors::new(self.config.enable_colors);

        println!("{}{}Ruchy Actor Observatory - Message Traces{}", 

                 colors.bold, colors.cyan, colors.reset);

        println!("{}", "─".repeat(self.terminal_size.0 as usize));

        let observatory = self.observatory.lock()

            .map_err(|_| anyhow::anyhow!("Failed to acquire observatory lock"))?;

        let traces = observatory.get_traces(Some(self.config.max_traces_display), None)?;

        if traces.is_empty() {

            println!("No message traces available");

            return Ok(());

        }

        // Table headers

        println!("{}Time     Source    Destination  Status      Duration  Message{}", 

                 colors.bold, colors.reset);

        println!("{}", "─".repeat(self.terminal_size.0 as usize));

        for trace in &traces {

            let timestamp = format_timestamp(trace.timestamp);

            let source = trace.source.map_or("external".to_string(), |id| id.to_string());

            let status_color = match trace.status {

                MessageStatus::Completed => colors.green,

                MessageStatus::Failed => colors.red,

                MessageStatus::Processing => colors.yellow,

                MessageStatus::Queued => colors.blue,

                MessageStatus::Dropped => colors.gray,

            };

            let duration_str = if let Some(duration) = trace.processing_duration_us {

                format!("{duration:>7}µs")

            } else {

                "       -".to_string()

            };

            let message_preview = format_message_preview(&trace.message);

            println!("{} {:<9} {:<12} {}{:<11}{} {} {}",

                     timestamp,

                     source,

                     trace.destination,

                     status_color,

                     format!("{:?}", trace.status),

                     colors.reset,

                     duration_str,

                     message_preview);

        }

        Ok(())

    }

    /// Render the system metrics view

    fn render_metrics(&self) -> Result<()> {

        let colors = Colors::new(self.config.enable_colors);

        println!("{}{}Ruchy Actor Observatory - System Metrics{}", 

                 colors.bold, colors.cyan, colors.reset);

        println!("{}", "─".repeat(self.terminal_size.0 as usize));

        let observatory = self.observatory.lock()

            .map_err(|_| anyhow::anyhow!("Failed to acquire observatory lock"))?;

        let metrics = observatory.get_metrics()?;

        let uptime = observatory.uptime();

        // System metrics

        println!("{}System Information:{}", colors.bold, colors.reset);

        println!("  Observatory Uptime: {}", format_duration(uptime));

        println!("  Last Updated: {}", format_timestamp(metrics.last_updated));

        println!();

        println!("{}Actor Metrics:{}", colors.bold, colors.reset);

        println!("  Active Actors: {}{}{}", colors.green, metrics.active_actors, colors.reset);

        println!("  Total Queued Messages: {}{}{}", colors.yellow, metrics.total_queued_messages, colors.reset);

        println!("  Average Mailbox Size: {}{:.2}{}", colors.cyan, metrics.avg_mailbox_size, colors.reset);

        println!("  Recent Restarts: {}{}{}", colors.red, metrics.recent_restarts, colors.reset);

        println!();

        println!("{}Performance Metrics:{}", colors.bold, colors.reset);