foxhunt/tli/src/dashboard/mod.rs

//! Dashboard Framework for TLI Terminal Interface
//!
//! This module provides a comprehensive dashboard system for the Foxhunt HFT trading system.
//! It implements a multi-dashboard architecture with real-time data streaming and interactive
//! controls using Ratatui for terminal-based visualization.
//!
//! ## Architecture
//! - **`DashboardManager`**: Central coordinator for all dashboards
//! - **Dashboard Trait**: Common interface for all dashboard implementations
//! - **Real-time Updates**: Event-driven data streaming from gRPC services
//! - **Navigation**: Keyboard shortcuts for dashboard switching
//! - **Layout Management**: Consistent UI layout across all dashboards

use anyhow::Result;
use crossterm::event::KeyEvent;
use ratatui::prelude::*;
use std::collections::HashMap;
use std::sync::Arc;
use tokio::sync::mpsc;

pub mod backtesting;
pub mod config;
pub mod events;
pub mod layout;
pub mod ml;
pub mod performance;
pub mod risk;
pub mod trading;
pub mod vault_status;

pub use backtesting::BacktestingDashboard;
// pub use foxhunt_config_crate::ConfigDashboard;
pub use crate::dashboards::config_manager::ConfigManagerDashboard as ConfigDashboard;
pub use events::*;
pub use layout::LayoutManager;
pub use ml::MLDashboard;
pub use performance::PerformanceDashboard;
pub use risk::RiskDashboard;
pub use trading::TradingDashboard;
pub use vault_status::VaultStatusWidget;

/// Main dashboard manager that coordinates all dashboards
pub struct DashboardManager {
    pub active_dashboard: DashboardType,
    pub dashboards: HashMap<DashboardType, Box<dyn Dashboard>>,
    pub layout_manager: LayoutManager,
    pub event_receiver: mpsc::Receiver<DashboardEvent>,
    pub event_sender: mpsc::Sender<DashboardEvent>,
    pub vault_service: Option<Arc<crate::vault::VaultService>>,
}

/// Available dashboard types
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum DashboardType {
    Trading,     // Live positions, orders, executions, market data
    Risk,        // VaR, drawdown, position limits, safety controls
    ML,          // Model predictions, signal strength, confidence
    Performance, // PnL, Sharpe ratios, strategy performance
    Config,      // System configuration management
    Backtesting, // Strategy testing, historical analysis, results
    Vault,       // Vault status, credentials, service discovery
}

impl DashboardType {
    pub fn all() -> Vec<DashboardType> {
        vec![
            DashboardType::Trading,
            DashboardType::Risk,
            DashboardType::ML,
            DashboardType::Performance,
            DashboardType::Config,
            DashboardType::Backtesting,
            DashboardType::Vault,
        ]
    }

    pub const fn shortcut_key(&self) -> char {
        match self {
            DashboardType::Trading => 't',
            DashboardType::Risk => 'r',
            DashboardType::ML => 'm',
            DashboardType::Performance => 'p',
            DashboardType::Config => 'c',
            DashboardType::Backtesting => 'b',
            DashboardType::Vault => 'v',
        }
    }

    pub const fn title(&self) -> &'static str {
        match self {
            DashboardType::Trading => "Trading",
            DashboardType::Risk => "Risk",
            DashboardType::ML => "ML",
            DashboardType::Performance => "Performance",
            DashboardType::Config => "Configuration",
            DashboardType::Backtesting => "Backtesting",
            DashboardType::Vault => "Vault Status",
        }
    }
}

/// Common interface for all dashboard implementations
pub trait Dashboard: Send + Sync {
    /// Render the dashboard to the given frame area
    fn render(&mut self, frame: &mut Frame, area: Rect) -> Result<()>;

    /// Handle keyboard input and return optional dashboard events
    fn handle_input(&mut self, key: KeyEvent) -> Result<Option<DashboardEvent>>;

    /// Update dashboard with new data/events
    fn update(&mut self, event: DashboardEvent) -> Result<()>;

    /// Get dashboard title for display
    fn title(&self) -> &str;

    /// Get keyboard shortcut for this dashboard
    fn shortcut_key(&self) -> char;

    /// Check if dashboard needs redraw
    fn needs_redraw(&self) -> bool;

    /// Mark dashboard as drawn
    fn mark_drawn(&mut self);
}

impl DashboardManager {
    pub fn new() -> (Self, mpsc::Sender<DashboardEvent>) {
        let (event_sender, event_receiver) = mpsc::channel(1000);

        let mut dashboards: HashMap<DashboardType, Box<dyn Dashboard>> = HashMap::new();

        // Initialize all dashboards
        dashboards.insert(
            DashboardType::Trading,
            Box::new(TradingDashboard::new(event_sender.clone())),
        );
        dashboards.insert(
            DashboardType::Risk,
            Box::new(RiskDashboard::new(event_sender.clone())),
        );
        dashboards.insert(
            DashboardType::ML,
            Box::new(MLDashboard::new(event_sender.clone())),
        );
        dashboards.insert(
            DashboardType::Performance,
            Box::new(PerformanceDashboard::new(event_sender.clone())),
        );
        dashboards.insert(
            DashboardType::Config,
            Box::new(ConfigDashboard::new(event_sender.clone())),
        );
        dashboards.insert(
            DashboardType::Backtesting,
            Box::new(BacktestingDashboard::new(event_sender.clone())),
        );
        dashboards.insert(
            DashboardType::Vault,
            Box::new(VaultStatusWidget::new(event_sender.clone())),
        );

        let manager = Self {
            active_dashboard: DashboardType::Trading,
            dashboards,
            layout_manager: LayoutManager::new(),
            event_receiver,
            event_sender: event_sender.clone(),
            vault_service: None,
        };

        (manager, event_sender)
    }

    pub fn render(&mut self, frame: &mut Frame) -> Result<()> {
        let area = frame.area();

        // Create main layout
        let (header_area, content_area, sidebar_area, footer_area) =
            self.layout_manager.create_layout(area);

        // Render header with navigation tabs
        self.render_header(frame, header_area)?;

        // Render active dashboard
        if let Some(dashboard) = self.dashboards.get_mut(&self.active_dashboard) {
            dashboard.render(frame, content_area)?;
        }

        // Render sidebar with quick stats
        self.render_sidebar(frame, sidebar_area)?;

        // Render footer with help and status
        self.render_footer(frame, footer_area)?;

        Ok(())
    }

    pub fn handle_input(&mut self, key: KeyEvent) -> Result<Option<DashboardEvent>> {
        // Check for dashboard switching shortcuts first
        for dashboard_type in DashboardType::all() {
            if key.code == crossterm::event::KeyCode::Char(dashboard_type.shortcut_key()) {
                self.active_dashboard = dashboard_type;
                return Ok(Some(DashboardEvent::SwitchDashboard(dashboard_type)));
            }
        }

        // Handle ESC for exit
        if key.code == crossterm::event::KeyCode::Esc {
            return Ok(Some(DashboardEvent::Exit));
        }

        // Pass input to active dashboard
        if let Some(dashboard) = self.dashboards.get_mut(&self.active_dashboard) {
            dashboard.handle_input(key)
        } else {
            Ok(None)
        }
    }

    pub async fn handle_event(&mut self, event: DashboardEvent) -> Result<bool> {
        match event {
            DashboardEvent::SwitchDashboard(dashboard_type) => {
                self.active_dashboard = dashboard_type;
                Ok(false)
            }
            DashboardEvent::Exit => {
                Ok(true) // Signal to exit
            }
            _ => {
                // Forward event to all dashboards that might be interested
                for dashboard in self.dashboards.values_mut() {
                    let _ = dashboard.update(event.clone());
                }
                Ok(false)
            }
        }
    }

    /// Set the Vault service for real-time status updates
    pub fn set_vault_service(&mut self, vault_service: Arc<crate::vault::VaultService>) {
        self.vault_service = Some(vault_service);
    }

    /// Update Vault dashboard with current stats
    pub async fn update_vault_dashboard(&mut self) -> Result<()> {
        if let Some(vault_service) = &self.vault_service {
            // Get current stats from Vault service
            let stats = self.collect_vault_stats(vault_service).await?;

            // Create event to update Vault dashboard
            let event = DashboardEvent::VaultStatusUpdate(stats);
            let _ = self.event_sender.send(event).await;
        }
        Ok(())
    }

    /// Collect current Vault statistics
    async fn collect_vault_stats(&self, vault_service: &Arc<crate::vault::VaultService>) -> Result<crate::dashboard::vault_status::VaultStats> {
        use crate::dashboard::vault_status::{VaultStats, VaultHealthStatus, RotationStats};

        // Check Vault health
        let health_status = if vault_service.health_check().await.is_ok() {
            VaultHealthStatus::Healthy
        } else {
            VaultHealthStatus::Unhealthy
        };

        // Get connection stats
        let connection_count = vault_service.get_active_connections().await.unwrap_or(0);
        let cache_hit_ratio = vault_service.get_cache_hit_ratio().await.unwrap_or(0.0);
        let credentials_cached = vault_service.get_cached_credentials_count().await.unwrap_or(0);
        let services_discovered = vault_service.get_discovered_services_count().await.unwrap_or(0);

        // Get rotation stats
        let rotation_stats = vault_service.get_rotation_stats().await.unwrap_or(RotationStats {
            total_rotations: 0,
            successful_rotations: 0,
            failed_rotations: 0,
            pending_rotations: 0,
        });

        Ok(VaultStats {
            health_status,
            connection_count,
            cache_hit_ratio,
            credentials_cached,
            services_discovered,
            last_health_check: Some(chrono::Utc::now()),
            rotation_stats,
        })
    }

    fn render_header(&self, frame: &mut Frame, area: Rect) -> Result<()> {
        let titles: Vec<String> = DashboardType::all()
            .iter()
            .map(|dt| {
                let _prefix = if *dt == self.active_dashboard {
                    "\u{25cf}"
                } else {
                    "\u{25cb}"
                };
                format!("[{}]{}", dt.shortcut_key().to_uppercase(), dt.title())
            })
            .collect();

        let tabs = ratatui::widgets::Tabs::new(titles)
            .block(
                ratatui::widgets::Block::default()
                    .borders(ratatui::widgets::Borders::ALL)
                    .title("Foxhunt HFT Trading System - TLI Terminal"),
            )
            .style(Style::default().fg(Color::White))
            .highlight_style(
                Style::default()
                    .fg(Color::Yellow)
                    .add_modifier(Modifier::BOLD),
            )
            .select(self.active_dashboard as usize);

        frame.render_widget(tabs, area);
        Ok(())
    }

    fn render_sidebar(&self, frame: &mut Frame, area: Rect) -> Result<()> {
        let block = ratatui::widgets::Block::default()
            .borders(ratatui::widgets::Borders::ALL)
            .title("Quick Stats");

        // Get actual Vault status if available
        let vault_status = if let Some(_vault_service) = &self.vault_service {
            // TODO: Get real-time status from VaultService
            "\u{25cf}" // Green dot for healthy
        } else {
            "\u{25cb}" // Empty circle for not available
        };

        let content = ratatui::widgets::Paragraph::new(
            format!(
                "Connection: \u{25cf}\u{25cf}\u{25cf}\nVault: {}\nLatency: 12ms\nOrders: 15\nPositions: 5\nPnL: +$2,500",
                vault_status
            ),
        )
        .block(block)
        .wrap(ratatui::widgets::Wrap { trim: true });

        frame.render_widget(content, area);
        Ok(())
    }

    fn render_footer(&self, frame: &mut Frame, area: Rect) -> Result<()> {
        let help_text = format!(
            "[{}] Dashboards | [ESC] Exit | Status: Connected",
            DashboardType::all()
                .iter()
                .map(|dt| format!(
                    "[{}]{}",
                    dt.shortcut_key().to_uppercase(),
                    dt.title().chars().next().unwrap()
                ))
                .collect::<Vec<_>>()
                .join(" ")
        );

        let footer = ratatui::widgets::Paragraph::new(help_text)
            .block(ratatui::widgets::Block::default().borders(ratatui::widgets::Borders::ALL))
            .style(Style::default().fg(Color::Gray));

        frame.render_widget(footer, area);
        Ok(())
    }
}