lens-core 1.0.0

//! # SLO Dashboard System for Real-Time Calibration Monitoring
//!
//! Production-ready dashboard and visualization system for Service Level Objectives (SLOs)
//! in calibration governance. Provides real-time monitoring dashboards, reliability diagrams,
//! per-bin calibration tables, and comprehensive drift reporting.
//!
//! ## Key Features
//!
//! * **Real-time SLO Monitoring**: Live dashboards with automatic refresh
//! * **Reliability Diagrams**: Visual SLO compliance over time
//! * **Per-bin Calibration Tables**: Detailed calibration analysis by bin
//! * **Weekly Drift Delta Reporting**: AECE, DECE, Brier, α tracking
//! * **Mask Mismatch Detection**: Fit vs eval environment validation
//! * **Interactive Visualizations**: Drill-down capabilities and filtering
//! * **Export Capabilities**: JSON, CSV, and image export support
//! * **Alert Integration**: Visual alerts and notification management
//!
//! ## Dashboard Components
//!
//! 1. **SLO Overview**: High-level system health and SLO compliance
//! 2. **Reliability Charts**: Time-series SLO performance visualization  
//! 3. **Calibration Tables**: Per-bin accuracy and coverage analysis
//! 4. **Drift Analysis**: Weekly delta tracking and trending
//! 5. **Alert Management**: Active alerts and incident response
//! 6. **Performance Metrics**: Latency, throughput, and resource usage

use crate::calibration::{
    slo_system::{SloSystem, SloReport, SloState, SloType, SloStatus, SystemHealth, ActiveAlert},
    CalibrationResult, CalibrationSample,
    monitoring::ECEMeasurement,
};
use anyhow::bail;
use anyhow::{Context, Result};
use chrono::{DateTime, Utc, Duration};
use serde::{Deserialize, Serialize};
use std::collections::{HashMap, VecDeque, BTreeMap};
use std::sync::Arc;
use tokio::sync::RwLock;
use tracing::{info, warn, error, debug};

/// SLO Dashboard system for visualization and monitoring
#[derive(Debug, Clone)]
pub struct SloDashboard {
    /// SLO system integration
    slo_system: Arc<SloSystem>,
    /// Dashboard configuration
    config: DashboardConfig,
    /// Dashboard state and data
    dashboard_state: Arc<RwLock<DashboardState>>,
    /// Visualization components
    visualizations: Arc<RwLock<VisualizationComponents>>,
    /// Export manager
    export_manager: Arc<ExportManager>,
}

/// Dashboard configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DashboardConfig {
    /// Auto-refresh interval
    pub refresh_interval: Duration,
    /// Data retention for dashboard
    pub data_retention: Duration,
    /// Maximum data points per chart
    pub max_data_points: usize,
    /// Default time range for displays
    pub default_time_range: TimeRange,
    /// Theme and styling
    pub theme: DashboardTheme,
    /// Export settings
    pub export_config: ExportConfig,
    /// Alert integration
    pub alert_integration: AlertIntegrationConfig,
}

/// Time range options for dashboard views
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum TimeRange {
    LastHour,
    Last6Hours,
    Last24Hours,
    LastWeek,
    LastMonth,
    Custom { start: DateTime<Utc>, end: DateTime<Utc> },
}

/// Dashboard theme configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DashboardTheme {
    /// Primary color scheme
    pub color_scheme: ColorScheme,
    /// Chart styles
    pub chart_style: ChartStyle,
    /// Font settings
    pub typography: Typography,
    /// Layout preferences
    pub layout: LayoutConfig,
}

/// Color scheme for dashboard elements
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ColorScheme {
    /// Primary colors
    pub primary: String,
    pub secondary: String,
    /// Status colors
    pub success: String,
    pub warning: String,
    pub error: String,
    pub info: String,
    /// Background colors
    pub background: String,
    pub surface: String,
    /// Text colors
    pub text_primary: String,
    pub text_secondary: String,
}

/// Chart styling configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChartStyle {
    /// Line chart settings
    pub line_width: f32,
    pub point_radius: f32,
    /// Bar chart settings
    pub bar_spacing: f32,
    pub bar_corner_radius: f32,
    /// Grid and axes
    pub grid_opacity: f32,
    pub axis_color: String,
}

/// Typography configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Typography {
    /// Font family
    pub font_family: String,
    /// Font sizes
    pub heading_size: f32,
    pub body_size: f32,
    pub caption_size: f32,
    /// Font weights
    pub heading_weight: String,
    pub body_weight: String,
}

/// Layout configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LayoutConfig {
    /// Grid system
    pub grid_columns: usize,
    pub grid_gap: f32,
    /// Spacing
    pub padding: f32,
    pub margin: f32,
    /// Component sizes
    pub component_min_height: f32,
    pub sidebar_width: f32,
}

/// Export configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ExportConfig {
    /// Supported formats
    pub supported_formats: Vec<ExportFormat>,
    /// Export quality settings
    pub image_quality: ImageQuality,
    /// Data export settings
    pub data_export: DataExportConfig,
}

/// Export format options
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ExportFormat {
    Json,
    Csv,
    Png,
    Svg,
    Pdf,
    Html,
}

/// Image export quality settings
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ImageQuality {
    pub dpi: u32,
    pub compression: f32,
    pub width: Option<u32>,
    pub height: Option<u32>,
}

/// Data export configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DataExportConfig {
    /// Include raw data in exports
    pub include_raw_data: bool,
    /// Include metadata
    pub include_metadata: bool,
    /// Maximum rows per export
    pub max_rows: usize,
    /// Date format for exports
    pub date_format: String,
}

/// Alert integration configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AlertIntegrationConfig {
    /// Show alerts in dashboard
    pub show_alerts: bool,
    /// Alert display duration
    pub alert_display_duration: Duration,
    /// Alert sound notifications
    pub sound_notifications: bool,
    /// Visual alert styling
    pub alert_styling: AlertStyling,
}

/// Alert visual styling
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AlertStyling {
    pub animation: AlertAnimation,
    pub position: AlertPosition,
    pub opacity: f32,
}

/// Alert animation options
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum AlertAnimation {
    None,
    Fade,
    Slide,
    Bounce,
    Pulse,
}

/// Alert position options
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum AlertPosition {
    TopLeft,
    TopRight,
    BottomLeft,
    BottomRight,
    Center,
}

/// Current dashboard state
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DashboardState {
    /// Last update timestamp
    pub last_updated: DateTime<Utc>,
    /// Current SLO state
    pub current_slo_state: Option<SloState>,
    /// Historical SLO data
    pub historical_data: HistoricalData,
    /// Dashboard metrics
    pub dashboard_metrics: DashboardMetrics,
    /// Active filters and views
    pub view_state: ViewState,
}

/// Historical data for trending and analysis
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HistoricalData {
    /// SLO measurements over time
    pub slo_history: HashMap<SloType, VecDeque<TimestampedValue>>,
    /// Breach events
    pub breach_events: VecDeque<BreachEvent>,
    /// Drift measurements
    pub drift_history: VecDeque<DriftMeasurement>,
    /// Calibration bin data
    pub calibration_history: VecDeque<CalibrationBinData>,
}

/// Timestamped value for time series data
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TimestampedValue {
    pub timestamp: DateTime<Utc>,
    pub value: f64,
    pub metadata: HashMap<String, String>,
}

/// Breach event for timeline visualization
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BreachEvent {
    pub timestamp: DateTime<Utc>,
    pub slo_type: SloType,
    pub severity: String,
    pub duration: Option<Duration>,
    pub resolved: bool,
}

/// Drift measurement data
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DriftMeasurement {
    pub timestamp: DateTime<Utc>,
    pub metric_name: String,
    pub current_value: f64,
    pub previous_value: f64,
    pub delta: f64,
    pub threshold_breached: bool,
}

/// Per-bin calibration data
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CalibrationBinData {
    pub timestamp: DateTime<Utc>,
    pub language: String,
    pub intent: String,
    pub bins: Vec<CalibrationBin>,
    pub overall_ece: f64,
    pub sample_count: usize,
}

/// Individual calibration bin
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CalibrationBin {
    pub bin_id: usize,
    pub confidence_range: (f64, f64),
    pub predicted_probability: f64,
    pub actual_accuracy: f64,
    pub sample_count: usize,
    pub bin_ece: f64,
    pub merged: bool,
}

/// Dashboard performance metrics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DashboardMetrics {
    /// Render times
    pub average_render_time_ms: f64,
    pub p99_render_time_ms: f64,
    /// Data loading times
    pub data_load_time_ms: f64,
    /// Update frequency
    pub updates_per_minute: f64,
    /// Memory usage
    pub memory_usage_mb: f64,
}

/// Current view state and filters
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ViewState {
    /// Selected time range
    pub time_range: TimeRange,
    /// Active filters
    pub filters: ViewFilters,
    /// Selected SLO types
    pub selected_slos: Vec<SloType>,
    /// Drill-down state
    pub drill_down: Option<DrillDownState>,
}

/// View filters for dashboard
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ViewFilters {
    /// Language filters
    pub languages: Vec<String>,
    /// Intent filters
    pub intents: Vec<String>,
    /// Severity filters
    pub severities: Vec<String>,
    /// Status filters
    pub statuses: Vec<String>,
}

/// Drill-down state for detailed views
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DrillDownState {
    pub slo_type: SloType,
    pub time_range: TimeRange,
    pub selected_slice: Option<String>,
}

/// Visualization components
#[derive(Debug, Clone)]
pub struct VisualizationComponents {
    /// SLO overview component
    pub slo_overview: SloOverviewComponent,
    /// Reliability chart component
    pub reliability_chart: ReliabilityChartComponent,
    /// Calibration table component
    pub calibration_table: CalibrationTableComponent,
    /// Drift analysis component
    pub drift_analysis: DriftAnalysisComponent,
    /// Alert panel component
    pub alert_panel: AlertPanelComponent,
}

/// SLO overview dashboard component
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SloOverviewComponent {
    /// Overall system health indicator
    pub system_health: SystemHealthIndicator,
    /// SLO status cards
    pub slo_cards: Vec<SloStatusCard>,
    /// Key metrics summary
    pub metrics_summary: MetricsSummary,
}

/// System health indicator
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SystemHealthIndicator {
    pub health: SystemHealth,
    pub health_score: f64, // 0.0 to 100.0
    pub status_text: String,
    pub last_updated: DateTime<Utc>,
}

/// SLO status card
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SloStatusCard {
    pub slo_type: SloType,
    pub current_value: f64,
    pub target_value: f64,
    pub status: String,
    pub trend: TrendIndicator,
    pub last_breach: Option<DateTime<Utc>>,
}

/// Trend indicator for SLO cards
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TrendIndicator {
    pub direction: String, // "up", "down", "stable"
    pub change_rate: f64,
    pub confidence: f64,
}

/// Metrics summary panel
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MetricsSummary {
    pub total_slos: usize,
    pub slos_meeting_target: usize,
    pub slos_at_warning: usize,
    pub slos_breached: usize,
    pub average_availability: f64,
    pub mttr_minutes: f64,
}

/// Reliability chart component
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ReliabilityChartComponent {
    /// Time series data for SLO compliance
    pub compliance_data: HashMap<SloType, Vec<TimestampedValue>>,
    /// Breach markers on timeline
    pub breach_markers: Vec<BreachMarker>,
    /// Target and warning lines
    pub threshold_lines: ThresholdLines,
    /// Chart configuration
    pub chart_config: ChartConfig,
}

/// Breach marker for timeline
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BreachMarker {
    pub timestamp: DateTime<Utc>,
    pub slo_type: SloType,
    pub severity: String,
    pub duration: Option<Duration>,
    pub tooltip: String,
}

/// Threshold lines for charts
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ThresholdLines {
    pub target_line: ThresholdLine,
    pub warning_line: ThresholdLine,
    pub critical_line: Option<ThresholdLine>,
}

/// Individual threshold line
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ThresholdLine {
    pub value: f64,
    pub color: String,
    pub style: String, // "solid", "dashed", "dotted"
    pub label: String,
}

/// Chart configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChartConfig {
    pub chart_type: ChartType,
    pub x_axis: AxisConfig,
    pub y_axis: AxisConfig,
    pub legend: LegendConfig,
    pub tooltips: TooltipConfig,
}

/// Chart type options
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ChartType {
    Line,
    Area,
    Bar,
    Scatter,
    Heatmap,
}

/// Axis configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AxisConfig {
    pub label: String,
    pub min: Option<f64>,
    pub max: Option<f64>,
    pub format: String,
    pub grid_lines: bool,
}

/// Legend configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LegendConfig {
    pub show: bool,
    pub position: String, // "top", "bottom", "left", "right"
    pub orientation: String, // "horizontal", "vertical"
}

/// Tooltip configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TooltipConfig {
    pub show: bool,
    pub format: String,
    pub include_metadata: bool,
}

/// Calibration table component
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CalibrationTableComponent {
    /// Current calibration data by slice
    pub calibration_slices: Vec<CalibrationSliceTable>,
    /// Bin-level statistics
    pub bin_statistics: BinStatistics,
    /// Mask mismatch detection
    pub mask_mismatch: MaskMismatchReport,
    /// Table configuration
    pub table_config: TableConfig,
}

/// Calibration data for a specific slice
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CalibrationSliceTable {
    pub slice_id: String,
    pub language: String,
    pub intent: String,
    pub bins: Vec<CalibrationBin>,
    pub overall_metrics: SliceMetrics,
    pub last_updated: DateTime<Utc>,
}

/// Overall metrics for a slice
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SliceMetrics {
    pub ece: f64,
    pub ace: f64, // Adaptive Calibration Error
    pub brier_score: f64,
    pub sample_count: usize,
    pub merged_bins: usize,
    pub clamp_activation_rate: f64,
}

/// Bin-level statistics across all slices
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BinStatistics {
    pub avg_samples_per_bin: f64,
    pub bin_coverage_distribution: Vec<f64>,
    pub merged_bin_rate: f64,
    pub empty_bin_count: usize,
}

/// Mask mismatch detection report
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MaskMismatchReport {
    pub fit_vs_eval_mismatches: Vec<MaskMismatch>,
    pub mismatch_rate: f64,
    pub affected_slices: Vec<String>,
    pub severity: String,
}

/// Individual mask mismatch
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MaskMismatch {
    pub slice_id: String,
    pub fit_mask: String,
    pub eval_mask: String,
    pub mismatch_type: String,
    pub impact_score: f64,
}

/// Table configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TableConfig {
    pub sortable_columns: Vec<String>,
    pub filterable_columns: Vec<String>,
    pub default_sort: String,
    pub page_size: usize,
    pub show_pagination: bool,
}

/// Drift analysis component
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DriftAnalysisComponent {
    /// Weekly drift delta report
    pub weekly_deltas: WeeklyDriftReport,
    /// Trend analysis
    pub trend_analysis: DriftTrendAnalysis,
    /// Alert thresholds visualization
    pub threshold_visualization: ThresholdVisualization,
}

/// Weekly drift report
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WeeklyDriftReport {
    pub report_week: DateTime<Utc>,
    pub metric_deltas: HashMap<String, DriftMetric>,
    pub overall_status: String,
    pub breached_thresholds: Vec<String>,
}

/// Individual drift metric
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DriftMetric {
    pub metric_name: String,
    pub current_value: f64,
    pub previous_value: f64,
    pub delta: f64,
    pub threshold: f64,
    pub status: String, // "ok", "warning", "breach"
}

/// Drift trend analysis
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DriftTrendAnalysis {
    pub trending_metrics: Vec<TrendingMetric>,
    pub stability_score: f64,
    pub prediction: DriftPrediction,
}

/// Trending metric information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TrendingMetric {
    pub metric_name: String,
    pub trend_direction: String,
    pub trend_strength: f64,
    pub time_to_breach: Option<Duration>,
}

/// Drift prediction
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DriftPrediction {
    pub predicted_breach_date: Option<DateTime<Utc>>,
    pub confidence: f64,
    pub recommended_actions: Vec<String>,
}

/// Threshold visualization
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ThresholdVisualization {
    pub threshold_lines: Vec<ThresholdLine>,
    pub current_values: HashMap<String, f64>,
    pub buffer_zones: Vec<BufferZone>,
}

/// Buffer zone for threshold visualization
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BufferZone {
    pub name: String,
    pub lower_bound: f64,
    pub upper_bound: f64,
    pub color: String,
    pub opacity: f32,
}

/// Alert panel component
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AlertPanelComponent {
    /// Active alerts
    pub active_alerts: Vec<AlertDisplayItem>,
    /// Recent alerts
    pub recent_alerts: Vec<AlertDisplayItem>,
    /// Alert statistics
    pub alert_stats: AlertStatistics,
}

/// Alert display item
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AlertDisplayItem {
    pub id: String,
    pub slo_type: SloType,
    pub severity: String,
    pub title: String,
    pub description: String,
    pub timestamp: DateTime<Utc>,
    pub status: String, // "active", "acknowledged", "resolved"
    pub assignee: Option<String>,
}

/// Alert statistics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AlertStatistics {
    pub total_alerts_today: usize,
    pub alerts_by_severity: HashMap<String, usize>,
    pub average_resolution_time: Duration,
    pub escalation_rate: f64,
}

/// Export manager for dashboard data and visualizations
#[derive(Debug, Clone)]
pub struct ExportManager {
    config: ExportConfig,
}

impl SloDashboard {
    /// Create new SLO dashboard
    pub fn new(slo_system: Arc<SloSystem>) -> Self {
        let config = Self::default_config();
        
        Self {
            slo_system,
            config,
            dashboard_state: Arc::new(RwLock::new(DashboardState::default())),
            visualizations: Arc::new(RwLock::new(VisualizationComponents::default())),
            export_manager: Arc::new(ExportManager::new(ExportConfig::default())),
        }
    }

    /// Create dashboard with custom configuration
    pub fn with_config(slo_system: Arc<SloSystem>, config: DashboardConfig) -> Self {
        Self {
            slo_system,
            config: config.clone(),
            dashboard_state: Arc::new(RwLock::new(DashboardState::default())),
            visualizations: Arc::new(RwLock::new(VisualizationComponents::default())),
            export_manager: Arc::new(ExportManager::new(config.export_config)),
        }
    }

    /// Start dashboard monitoring and updates
    pub async fn start(&self) -> Result<()> {
        info!("Starting SLO dashboard");

        // Start data refresh loop
        let dashboard = self.clone();
        tokio::spawn(async move {
            dashboard.refresh_loop().await;
        });

        info!("SLO dashboard started successfully");
        Ok(())
    }

    /// Main refresh loop for dashboard data
    async fn refresh_loop(&self) {
        let mut interval = tokio::time::interval(self.config.refresh_interval);
        
        loop {
            interval.tick().await;
            
            if let Err(e) = self.refresh_dashboard_data().await {
                error!("Error refreshing dashboard data: {}", e);
            }
        }
    }

    /// Refresh all dashboard data
    async fn refresh_dashboard_data(&self) -> Result<()> {
        debug!("Refreshing dashboard data");
        
        // Get current SLO state
        let slo_state = self.slo_system.get_slo_state().await;
        
        // Update dashboard state
        let mut state = self.dashboard_state.write().await;
        state.current_slo_state = Some(slo_state.clone());
        state.last_updated = Utc::now();
        
        // Update historical data
        self.update_historical_data(&slo_state).await?;
        
        // Update visualizations
        self.update_visualizations().await?;
        
        debug!("Dashboard data refreshed successfully");
        Ok(())
    }

    /// Update historical data with new measurements
    async fn update_historical_data(&self, slo_state: &SloState) -> Result<()> {
        let mut state = self.dashboard_state.write().await;
        
        // Update SLO history
        for (slo_type, slo_status) in &slo_state.slo_status {
            let history = state.historical_data.slo_history
                .entry(slo_type.clone())
                .or_insert_with(VecDeque::new);
                
            history.push_back(TimestampedValue {
                timestamp: slo_status.last_measured,
                value: slo_status.current_value,
                metadata: HashMap::new(),
            });
            
            // Maintain maximum data points
            while history.len() > self.config.max_data_points {
                history.pop_front();
            }
        }
        
        // Add breach events for breached SLOs
        for (slo_type, slo_status) in &slo_state.slo_status {
            if matches!(slo_status.status, crate::calibration::slo_system::SloHealthStatus::Breached) {
                state.historical_data.breach_events.push_back(BreachEvent {
                    timestamp: slo_status.last_measured,
                    slo_type: slo_type.clone(),
                    severity: "critical".to_string(),
                    duration: None,
                    resolved: false,
                });
            }
        }
        
        Ok(())
    }

    /// Update visualization components
    async fn update_visualizations(&self) -> Result<()> {
        let state = self.dashboard_state.read().await;
        let mut visualizations = self.visualizations.write().await;
        
        if let Some(slo_state) = &state.current_slo_state {
            // Update SLO overview
            visualizations.slo_overview = self.create_slo_overview(slo_state).await?;
            
            // Update reliability chart
            visualizations.reliability_chart = self.create_reliability_chart(&state.historical_data).await?;
            
            // Update calibration table
            visualizations.calibration_table = self.create_calibration_table().await?;
            
            // Update drift analysis
            visualizations.drift_analysis = self.create_drift_analysis().await?;
            
            // Update alert panel
            visualizations.alert_panel = self.create_alert_panel(&slo_state.active_alerts).await?;
        }
        
        Ok(())
    }

    /// Create SLO overview component
    async fn create_slo_overview(&self, slo_state: &SloState) -> Result<SloOverviewComponent> {
        let system_health = SystemHealthIndicator {
            health: slo_state.overall_health.clone(),
            health_score: self.calculate_health_score(slo_state),
            status_text: format!("{:?}", slo_state.overall_health),
            last_updated: slo_state.last_measurement,
        };

        let mut slo_cards = Vec::new();
        for (slo_type, slo_status) in &slo_state.slo_status {
            slo_cards.push(SloStatusCard {
                slo_type: slo_type.clone(),
                current_value: slo_status.current_value,
                target_value: slo_status.target_value,
                status: format!("{:?}", slo_status.status),
                trend: TrendIndicator {
                    direction: format!("{:?}", slo_status.trend.direction),
                    change_rate: slo_status.trend.rate,
                    confidence: slo_status.trend.confidence,
                },
                last_breach: None, // Would be calculated from breach history
            });
        }

        let metrics_summary = MetricsSummary {
            total_slos: slo_state.slo_status.len(),
            slos_meeting_target: slo_state.slo_status.values()
                .filter(|s| matches!(s.status, crate::calibration::slo_system::SloHealthStatus::Meeting))
                .count(),
            slos_at_warning: slo_state.slo_status.values()
                .filter(|s| matches!(s.status, crate::calibration::slo_system::SloHealthStatus::Warning))
                .count(),
            slos_breached: slo_state.slo_status.values()
                .filter(|s| matches!(s.status, crate::calibration::slo_system::SloHealthStatus::Breached))
                .count(),
            average_availability: 99.5, // Would calculate from history
            mttr_minutes: 15.0, // Would calculate from history
        };

        Ok(SloOverviewComponent {
            system_health,
            slo_cards,
            metrics_summary,
        })
    }

    /// Calculate overall system health score
    fn calculate_health_score(&self, slo_state: &SloState) -> f64 {
        let total_slos = slo_state.slo_status.len() as f64;
        if total_slos == 0.0 {
            return 100.0;
        }

        let meeting_count = slo_state.slo_status.values()
            .filter(|s| matches!(s.status, crate::calibration::slo_system::SloHealthStatus::Meeting))
            .count() as f64;

        let warning_count = slo_state.slo_status.values()
            .filter(|s| matches!(s.status, crate::calibration::slo_system::SloHealthStatus::Warning))
            .count() as f64;

        // Score: 100 for meeting, 70 for warning, 0 for breached
        let score = (meeting_count * 100.0 + warning_count * 70.0) / total_slos;
        score.round()
    }

    /// Create reliability chart component
    async fn create_reliability_chart(&self, historical_data: &HistoricalData) -> Result<ReliabilityChartComponent> {
        let mut compliance_data = HashMap::new();
        
        for (slo_type, history) in &historical_data.slo_history {
            compliance_data.insert(slo_type.clone(), history.clone().into());
        }

        let breach_markers = historical_data.breach_events.iter()
            .map(|event| BreachMarker {
                timestamp: event.timestamp,
                slo_type: event.slo_type.clone(),
                severity: event.severity.clone(),
                duration: event.duration,
                tooltip: format!("SLO breach: {:?} - {}", event.slo_type, event.severity),
            })
            .collect();

        let threshold_lines = ThresholdLines {
            target_line: ThresholdLine {
                value: 1.0,
                color: "#28a745".to_string(),
                style: "solid".to_string(),
                label: "Target".to_string(),
            },
            warning_line: ThresholdLine {
                value: 0.9,
                color: "#ffc107".to_string(),
                style: "dashed".to_string(),
                label: "Warning".to_string(),
            },
            critical_line: Some(ThresholdLine {
                value: 0.8,
                color: "#dc3545".to_string(),
                style: "dotted".to_string(),
                label: "Critical".to_string(),
            }),
        };

        let chart_config = ChartConfig {
            chart_type: ChartType::Line,
            x_axis: AxisConfig {
                label: "Time".to_string(),
                min: None,
                max: None,
                format: "%H:%M".to_string(),
                grid_lines: true,
            },
            y_axis: AxisConfig {
                label: "SLO Compliance".to_string(),
                min: Some(0.0),
                max: Some(1.2),
                format: "%.2f".to_string(),
                grid_lines: true,
            },
            legend: LegendConfig {
                show: true,
                position: "bottom".to_string(),
                orientation: "horizontal".to_string(),
            },
            tooltips: TooltipConfig {
                show: true,
                format: "{series}: {value} at {timestamp}".to_string(),
                include_metadata: true,
            },
        };

        Ok(ReliabilityChartComponent {
            compliance_data,
            breach_markers,
            threshold_lines,
            chart_config,
        })
    }

    /// Create calibration table component
    async fn create_calibration_table(&self) -> Result<CalibrationTableComponent> {
        // This would integrate with actual calibration data
        // For now, returning a placeholder structure
        
        Ok(CalibrationTableComponent {
            calibration_slices: vec![],
            bin_statistics: BinStatistics {
                avg_samples_per_bin: 0.0,
                bin_coverage_distribution: vec![],
                merged_bin_rate: 0.0,
                empty_bin_count: 0,
            },
            mask_mismatch: MaskMismatchReport {
                fit_vs_eval_mismatches: vec![],
                mismatch_rate: 0.0,
                affected_slices: vec![],
                severity: "none".to_string(),
            },
            table_config: TableConfig {
                sortable_columns: vec!["bin_id".to_string(), "ece".to_string()],
                filterable_columns: vec!["language".to_string(), "intent".to_string()],
                default_sort: "bin_id".to_string(),
                page_size: 25,
                show_pagination: true,
            },
        })
    }

    /// Create drift analysis component
    async fn create_drift_analysis(&self) -> Result<DriftAnalysisComponent> {
        Ok(DriftAnalysisComponent {
            weekly_deltas: WeeklyDriftReport {
                report_week: Utc::now(),
                metric_deltas: HashMap::new(),
                overall_status: "stable".to_string(),
                breached_thresholds: vec![],
            },
            trend_analysis: DriftTrendAnalysis {
                trending_metrics: vec![],
                stability_score: 95.0,
                prediction: DriftPrediction {
                    predicted_breach_date: None,
                    confidence: 0.8,
                    recommended_actions: vec!["Monitor trend".to_string()],
                },
            },
            threshold_visualization: ThresholdVisualization {
                threshold_lines: vec![],
                current_values: HashMap::new(),
                buffer_zones: vec![],
            },
        })
    }

    /// Create alert panel component
    async fn create_alert_panel(&self, active_alerts: &[crate::calibration::slo_system::ActiveAlert]) -> Result<AlertPanelComponent> {
        let alert_items: Vec<AlertDisplayItem> = active_alerts.iter()
            .map(|alert| AlertDisplayItem {
                id: alert.id.clone(),
                slo_type: alert.slo_type.clone(),
                severity: format!("{:?}", alert.severity),
                title: format!("SLO Alert: {}", alert.slo_type.name()),
                description: alert.message.clone(),
                timestamp: alert.started_at,
                status: if alert.acknowledged { "acknowledged" } else { "active" }.to_string(),
                assignee: None,
            })
            .collect();

        let alert_stats = AlertStatistics {
            total_alerts_today: active_alerts.len(),
            alerts_by_severity: HashMap::new(), // Would calculate from data
            average_resolution_time: Duration::minutes(30),
            escalation_rate: 0.1,
        };

        Ok(AlertPanelComponent {
            active_alerts: alert_items.clone(),
            recent_alerts: alert_items,
            alert_stats,
        })
    }

    /// Export dashboard data in specified format
    pub async fn export(&self, format: ExportFormat, filters: Option<ViewFilters>) -> Result<Vec<u8>> {
        self.export_manager.export_dashboard_data(
            &self.dashboard_state.read().await,
            format,
            filters,
        ).await
    }

    /// Get current dashboard state
    pub async fn get_dashboard_state(&self) -> DashboardState {
        self.dashboard_state.read().await.clone()
    }

    /// Get current visualizations
    pub async fn get_visualizations(&self) -> VisualizationComponents {
        self.visualizations.read().await.clone()
    }

    /// Create default dashboard configuration
    fn default_config() -> DashboardConfig {
        DashboardConfig {
            refresh_interval: Duration::seconds(30),
            data_retention: Duration::days(7),
            max_data_points: 1000,
            default_time_range: TimeRange::Last24Hours,
            theme: DashboardTheme::default(),
            export_config: ExportConfig::default(),
            alert_integration: AlertIntegrationConfig {
                show_alerts: true,
                alert_display_duration: Duration::seconds(30),
                sound_notifications: false,
                alert_styling: AlertStyling {
                    animation: AlertAnimation::Fade,
                    position: AlertPosition::TopRight,
                    opacity: 0.9,
                },
            },
        }
    }
}

impl ExportManager {
    pub fn new(config: ExportConfig) -> Self {
        Self { config }
    }

    pub async fn export_dashboard_data(
        &self,
        dashboard_state: &DashboardState,
        format: ExportFormat,
        _filters: Option<ViewFilters>,
    ) -> Result<Vec<u8>> {
        match format {
            ExportFormat::Json => {
                let json = serde_json::to_string_pretty(dashboard_state)?;
                Ok(json.into_bytes())
            }
            ExportFormat::Csv => {
                // Would implement CSV export logic
                Ok(b"CSV export not yet implemented".to_vec())
            }
            _ => {
                bail!("Export format not supported: {:?}", format)
            }
        }
    }
}

// Default implementations
impl Default for DashboardState {
    fn default() -> Self {
        Self {
            last_updated: Utc::now(),
            current_slo_state: None,
            historical_data: HistoricalData {
                slo_history: HashMap::new(),
                breach_events: VecDeque::new(),
                drift_history: VecDeque::new(),
                calibration_history: VecDeque::new(),
            },
            dashboard_metrics: DashboardMetrics {
                average_render_time_ms: 0.0,
                p99_render_time_ms: 0.0,
                data_load_time_ms: 0.0,
                updates_per_minute: 0.0,
                memory_usage_mb: 0.0,
            },
            view_state: ViewState {
                time_range: TimeRange::Last24Hours,
                filters: ViewFilters {
                    languages: vec![],
                    intents: vec![],
                    severities: vec![],
                    statuses: vec![],
                },
                selected_slos: vec![],
                drill_down: None,
            },
        }
    }
}

impl Default for VisualizationComponents {
    fn default() -> Self {
        Self {
            slo_overview: SloOverviewComponent {
                system_health: SystemHealthIndicator {
                    health: SystemHealth::Healthy,
                    health_score: 100.0,
                    status_text: "Healthy".to_string(),
                    last_updated: Utc::now(),
                },
                slo_cards: vec![],
                metrics_summary: MetricsSummary {
                    total_slos: 0,
                    slos_meeting_target: 0,
                    slos_at_warning: 0,
                    slos_breached: 0,
                    average_availability: 100.0,
                    mttr_minutes: 0.0,
                },
            },
            reliability_chart: ReliabilityChartComponent {
                compliance_data: HashMap::new(),
                breach_markers: vec![],
                threshold_lines: ThresholdLines {
                    target_line: ThresholdLine {
                        value: 1.0,
                        color: "#28a745".to_string(),
                        style: "solid".to_string(),
                        label: "Target".to_string(),
                    },
                    warning_line: ThresholdLine {
                        value: 0.9,
                        color: "#ffc107".to_string(),
                        style: "dashed".to_string(),
                        label: "Warning".to_string(),
                    },
                    critical_line: None,
                },
                chart_config: ChartConfig {
                    chart_type: ChartType::Line,
                    x_axis: AxisConfig {
                        label: "Time".to_string(),
                        min: None,
                        max: None,
                        format: "%H:%M".to_string(),
                        grid_lines: true,
                    },
                    y_axis: AxisConfig {
                        label: "Value".to_string(),
                        min: None,
                        max: None,
                        format: "%.2f".to_string(),
                        grid_lines: true,
                    },
                    legend: LegendConfig {
                        show: true,
                        position: "bottom".to_string(),
                        orientation: "horizontal".to_string(),
                    },
                    tooltips: TooltipConfig {
                        show: true,
                        format: "{value}".to_string(),
                        include_metadata: false,
                    },
                },
            },
            calibration_table: CalibrationTableComponent {
                calibration_slices: vec![],
                bin_statistics: BinStatistics {
                    avg_samples_per_bin: 0.0,
                    bin_coverage_distribution: vec![],
                    merged_bin_rate: 0.0,
                    empty_bin_count: 0,
                },
                mask_mismatch: MaskMismatchReport {
                    fit_vs_eval_mismatches: vec![],
                    mismatch_rate: 0.0,
                    affected_slices: vec![],
                    severity: "none".to_string(),
                },
                table_config: TableConfig {
                    sortable_columns: vec![],
                    filterable_columns: vec![],
                    default_sort: "id".to_string(),
                    page_size: 25,
                    show_pagination: true,
                },
            },
            drift_analysis: DriftAnalysisComponent {
                weekly_deltas: WeeklyDriftReport {
                    report_week: Utc::now(),
                    metric_deltas: HashMap::new(),
                    overall_status: "stable".to_string(),
                    breached_thresholds: vec![],
                },
                trend_analysis: DriftTrendAnalysis {
                    trending_metrics: vec![],
                    stability_score: 100.0,
                    prediction: DriftPrediction {
                        predicted_breach_date: None,
                        confidence: 1.0,
                        recommended_actions: vec![],
                    },
                },
                threshold_visualization: ThresholdVisualization {
                    threshold_lines: vec![],
                    current_values: HashMap::new(),
                    buffer_zones: vec![],
                },
            },
            alert_panel: AlertPanelComponent {
                active_alerts: vec![],
                recent_alerts: vec![],
                alert_stats: AlertStatistics {
                    total_alerts_today: 0,
                    alerts_by_severity: HashMap::new(),
                    average_resolution_time: Duration::seconds(0),
                    escalation_rate: 0.0,
                },
            },
        }
    }
}

impl Default for DashboardTheme {
    fn default() -> Self {
        Self {
            color_scheme: ColorScheme {
                primary: "#007bff".to_string(),
                secondary: "#6c757d".to_string(),
                success: "#28a745".to_string(),
                warning: "#ffc107".to_string(),
                error: "#dc3545".to_string(),
                info: "#17a2b8".to_string(),
                background: "#ffffff".to_string(),
                surface: "#f8f9fa".to_string(),
                text_primary: "#212529".to_string(),
                text_secondary: "#6c757d".to_string(),
            },
            chart_style: ChartStyle {
                line_width: 2.0,
                point_radius: 4.0,
                bar_spacing: 0.1,
                bar_corner_radius: 2.0,
                grid_opacity: 0.3,
                axis_color: "#6c757d".to_string(),
            },
            typography: Typography {
                font_family: "system-ui, -apple-system, sans-serif".to_string(),
                heading_size: 24.0,
                body_size: 14.0,
                caption_size: 12.0,
                heading_weight: "600".to_string(),
                body_weight: "400".to_string(),
            },
            layout: LayoutConfig {
                grid_columns: 12,
                grid_gap: 16.0,
                padding: 16.0,
                margin: 8.0,
                component_min_height: 200.0,
                sidebar_width: 250.0,
            },
        }
    }
}

impl Default for ExportConfig {
    fn default() -> Self {
        Self {
            supported_formats: vec![
                ExportFormat::Json,
                ExportFormat::Csv,
                ExportFormat::Png,
            ],
            image_quality: ImageQuality {
                dpi: 300,
                compression: 0.8,
                width: None,
                height: None,
            },
            data_export: DataExportConfig {
                include_raw_data: true,
                include_metadata: true,
                max_rows: 10000,
                date_format: "%Y-%m-%d %H:%M:%S".to_string(),
            },
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn test_dashboard_creation() {
        // Test would verify dashboard creation and initialization
    }

    #[tokio::test]
    async fn test_data_refresh() {
        // Test would verify data refresh functionality
    }

    #[tokio::test]
    async fn test_export_functionality() {
        // Test would verify export capabilities
    }
}