quantrs2-device 0.1.3

//! Performance Analytics Dashboard
//!
//! This module has been refactored from a monolithic 3,092-line file into a clean,
//! modular architecture to eliminate configuration explosion and improve maintainability.
//!
//! ## Module Structure
//!
//! - `config`: Configuration management (dashboard, analytics, visualization settings)
//! - `analytics`: Analytics engines (statistical, trend, anomaly detection, prediction)
//! - `alerting`: Alert management and notification systems
//! - `data`: Data collection, storage, and quality monitoring
//! - `visualization`: Dashboard rendering and chart generation
//! - `session`: User session and permission management
//!
//! ## Key Improvements
//!
//! - **Configuration Organization**: Massive config structs organized into logical modules
//! - **Separation of Concerns**: Each module handles a specific dashboard aspect
//! - **Maintainability**: ~400-500 lines per module vs. 3,092 lines in single file
//! - **Testability**: Independent testing of analytics engines and components
//! - **Extensibility**: Easy to add new analytics or visualization features

use std::collections::{BTreeMap, HashMap, VecDeque};
use std::sync::{Arc, Mutex, RwLock};
use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};

// Import specific types to avoid naming conflicts
use quantrs2_circuit::prelude::{
    PerformanceAnalyzer,
    PerformanceSnapshot,
    PerformanceSummary,
    ProfilerConfig as ProfilerConfiguration,
    // Avoid importing RealtimeMetrics, AnomalyDetectionAlgorithm, StorageConfig, StorageBackend
    // to prevent conflicts with local types
    ProfilingReport,
    ProfilingSession,
    QuantumProfiler,
};
use quantrs2_core::{
    error::{QuantRS2Error, QuantRS2Result},
    gate::GateOp,
    qubit::QubitId,
};

// SciRS2 dependencies for advanced analytics
#[cfg(feature = "scirs2")]
use scirs2_graph::{
    betweenness_centrality, closeness_centrality, dijkstra_path, minimum_spanning_tree,
    strongly_connected_components, Graph,
};
#[cfg(feature = "scirs2")]
use scirs2_linalg::{
    cholesky, det, eig, inv, matrix_norm, prelude::*, qr, svd, trace, LinalgError, LinalgResult,
};
#[cfg(feature = "scirs2")]
use scirs2_optimize::{minimize, OptimizeResult};
#[cfg(feature = "scirs2")]
use scirs2_stats::{
    corrcoef,
    distributions::{chi2, exponential, gamma, norm},
    ks_2samp, mean, pearsonr, shapiro_wilk, spearmanr, std, ttest_1samp, ttest_ind, var,
    Alternative, TTestResult,
};

// Fallback implementations when SciRS2 is not available
#[cfg(not(feature = "scirs2"))]
mod fallback_scirs2 {
    use scirs2_core::ndarray::{Array1, Array2, ArrayView1, ArrayView2};

    pub fn mean(_data: &ArrayView1<f64>) -> Result<f64, String> {
        Ok(0.0)
    }
    pub fn std(_data: &ArrayView1<f64>, _ddof: i32) -> Result<f64, String> {
        Ok(1.0)
    }
    pub fn pearsonr(
        _x: &ArrayView1<f64>,
        _y: &ArrayView1<f64>,
        _alt: &str,
    ) -> Result<(f64, f64), String> {
        Ok((0.0, 0.5))
    }
    pub fn trace(_matrix: &ArrayView2<f64>) -> Result<f64, String> {
        Ok(1.0)
    }
    pub fn inv(_matrix: &ArrayView2<f64>) -> Result<Array2<f64>, String> {
        Ok(Array2::eye(2))
    }

    pub struct OptimizeResult {
        pub x: Array1<f64>,
        pub fun: f64,
        pub success: bool,
        pub nit: usize,
        pub nfev: usize,
        pub message: String,
    }

    pub fn minimize(
        _func: fn(&Array1<f64>) -> f64,
        _x0: &Array1<f64>,
        _method: &str,
    ) -> Result<OptimizeResult, String> {
        Ok(OptimizeResult {
            x: Array1::zeros(2),
            fun: 0.0,
            success: true,
            nit: 0,
            nfev: 0,
            message: "Fallback optimization".to_string(),
        })
    }
}

#[cfg(not(feature = "scirs2"))]
use fallback_scirs2::*;

use scirs2_core::ndarray::{s, Array1, Array2, Array3, Array4, ArrayView1, ArrayView2, Axis};
use scirs2_core::random::prelude::*;
use scirs2_core::Complex64;
use serde::{Deserialize, Serialize};
use tokio::sync::{broadcast, mpsc};

use crate::{
    adaptive_compilation::AdaptiveCompilationConfig,
    backend_traits::{query_backend_capabilities, BackendCapabilities},
    calibration::{CalibrationManager, DeviceCalibration},
    integrated_device_manager::{
        IntegratedExecutionResult, IntegratedQuantumDeviceManager, PerformanceAnalytics,
    },
    ml_optimization::MLOptimizationConfig,
    topology::HardwareTopology,
    CircuitResult, DeviceError, DeviceResult,
};

// Module declarations
pub mod alerting;
pub mod analytics;
pub mod config;
pub mod data;
pub mod session;
pub mod visualization;

// Re-exports for backward compatibility
pub use alerting::{AlertManager, NotificationDispatcher}; // Specific imports to avoid ActiveAlert conflict
pub use analytics::{AnomalyDetector, PerformancePredictor, StatisticalAnalyzer, TrendAnalyzer}; // Specific imports to avoid Anomaly conflict
pub use config::*;
pub use data::*; // Keep data::Anomaly and data::ActiveAlert as primary
pub use session::*;
pub use visualization::*;

/// Main Performance Analytics Dashboard
pub struct PerformanceAnalyticsDashboard {
    config: PerformanceDashboardConfig,
    integrated_manager: Option<Arc<IntegratedQuantumDeviceManager>>,
    ml_engine: Option<Arc<Mutex<MLOptimizationConfig>>>,
    compilation_pipeline: Option<Arc<AdaptiveCompilationConfig>>,

    // Data storage and caching
    realtime_data: Arc<RwLock<RealtimeMetrics>>,
    historical_data: Arc<RwLock<HistoricalData>>,
    statistical_cache: Arc<Mutex<StatisticalAnalysisResults>>,
    prediction_cache: Arc<Mutex<PerformancePredictions>>,
    alert_manager: Arc<Mutex<AlertManager>>,

    // Analytics engines
    statistical_analyzer: Arc<Mutex<StatisticalAnalyzer>>,
    trend_analyzer: Arc<Mutex<TrendAnalyzer>>,
    anomaly_detector: Arc<Mutex<AnomalyDetector>>,
    predictor: Arc<Mutex<PerformancePredictor>>,

    // Communication channels
    event_sender: broadcast::Sender<DashboardEvent>,
    data_collector: Arc<Mutex<DataCollector>>,

    // State management
    dashboard_state: Arc<RwLock<DashboardState>>,
    user_sessions: Arc<Mutex<HashMap<String, UserSession>>>,
}

/// Dashboard event types
#[derive(Debug, Clone)]
pub enum DashboardEvent {
    MetricsUpdated(RealtimeMetrics),
    AlertTriggered(ActiveAlert),
    AlertResolved(String),
    AnomalyDetected(Anomaly),
    PredictionUpdated(PerformancePredictions),
    UserAction(UserAction),
    SystemStatusChanged(SystemStatus),
}

/// Dashboard state management
#[derive(Debug, Clone)]
pub struct DashboardState {
    pub current_view: DashboardView,
    pub filters: Vec<DataFilter>,
    pub time_range: TimeRange,
    pub aggregation_level: AggregationLevel,
    pub refresh_enabled: bool,
    pub last_update: SystemTime,
}

/// Dashboard view types
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum DashboardView {
    Overview,
    RealTimeMetrics,
    HistoricalAnalysis,
    PredictiveAnalytics,
    Alerts,
    CustomView(String),
}

/// Data filter for queries
#[derive(Debug, Clone)]
pub struct DataFilter {
    pub field: String,
    pub operator: FilterOperator,
    pub value: FilterValue,
}

/// Filter operators
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum FilterOperator {
    Equals,
    NotEquals,
    GreaterThan,
    LessThan,
    Contains,
    StartsWith,
    EndsWith,
    InRange,
}

/// Filter value types
#[derive(Debug, Clone)]
pub enum FilterValue {
    String(String),
    Number(f64),
    Boolean(bool),
    Range(f64, f64),
    List(Vec<String>),
}

/// Time range specification
#[derive(Debug, Clone)]
pub struct TimeRange {
    pub start: SystemTime,
    pub end: SystemTime,
}

/// User action tracking
#[derive(Debug, Clone)]
pub struct UserAction {
    pub user_id: String,
    pub action_type: ActionType,
    pub timestamp: SystemTime,
    pub details: HashMap<String, String>,
}

/// Action types
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ActionType {
    ViewChange,
    FilterApplied,
    ExportRequested,
    AlertAcknowledged,
    ConfigurationChanged,
    CustomQuery,
}

/// System status
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum SystemStatus {
    Healthy,
    Warning,
    Error,
    Maintenance,
    Unknown,
}

impl PerformanceAnalyticsDashboard {
    /// Create a new performance analytics dashboard
    pub fn new(config: PerformanceDashboardConfig) -> DeviceResult<Self> {
        let (event_sender, _) = broadcast::channel(1000);

        Ok(Self {
            config: config.clone(),
            integrated_manager: None,
            ml_engine: None,
            compilation_pipeline: None,
            realtime_data: Arc::new(RwLock::new(RealtimeMetrics::new())),
            historical_data: Arc::new(RwLock::new(HistoricalData::new())),
            statistical_cache: Arc::new(Mutex::new(StatisticalAnalysisResults::new())),
            prediction_cache: Arc::new(Mutex::new(PerformancePredictions::new())),
            alert_manager: Arc::new(Mutex::new(AlertManager::new(config.alert_config.clone()))),
            statistical_analyzer: Arc::new(Mutex::new(StatisticalAnalyzer::new(
                config.analytics_config.clone(),
            ))),
            trend_analyzer: Arc::new(Mutex::new(TrendAnalyzer::new(
                config.analytics_config.clone(),
            ))),
            anomaly_detector: Arc::new(Mutex::new(AnomalyDetector::new(
                config.analytics_config.clone(),
            ))),
            predictor: Arc::new(Mutex::new(PerformancePredictor::new(
                config.prediction_config.clone(),
            ))),
            event_sender,
            data_collector: Arc::new(Mutex::new(DataCollector::new(config))),
            dashboard_state: Arc::new(RwLock::new(DashboardState::default())),
            user_sessions: Arc::new(Mutex::new(HashMap::new())),
        })
    }

    /// Initialize dashboard with device manager
    #[must_use]
    pub fn with_device_manager(mut self, manager: Arc<IntegratedQuantumDeviceManager>) -> Self {
        self.integrated_manager = Some(manager);
        self
    }

    /// Initialize dashboard with ML optimization engine
    #[must_use]
    pub fn with_ml_engine(mut self, engine: Arc<Mutex<MLOptimizationConfig>>) -> Self {
        self.ml_engine = Some(engine);
        self
    }

    /// Initialize dashboard with compilation pipeline
    #[must_use]
    pub fn with_compilation_pipeline(mut self, pipeline: Arc<AdaptiveCompilationConfig>) -> Self {
        self.compilation_pipeline = Some(pipeline);
        self
    }

    /// Start the dashboard and begin data collection
    pub async fn start(&self) -> DeviceResult<()> {
        // Start data collection
        let collector = self.data_collector.clone();
        let mut collector_guard = collector.lock().unwrap_or_else(|e| e.into_inner());
        collector_guard.start_collection().await?;
        drop(collector_guard);

        // Start analytics engines
        self.start_analytics_engines().await?;

        // Start alert monitoring
        let alert_manager = self.alert_manager.clone();
        let mut alert_guard = alert_manager.lock().unwrap_or_else(|e| e.into_inner());
        alert_guard.start_monitoring().await?;
        drop(alert_guard);

        Ok(())
    }

    /// Stop the dashboard
    pub async fn stop(&self) -> DeviceResult<()> {
        // Stop data collection
        let collector = self.data_collector.clone();
        let mut collector_guard = collector.lock().unwrap_or_else(|e| e.into_inner());
        collector_guard.stop_collection().await?;
        drop(collector_guard);

        // Stop analytics engines
        self.stop_analytics_engines().await?;

        // Stop alert monitoring
        let alert_manager = self.alert_manager.clone();
        let mut alert_guard = alert_manager.lock().unwrap_or_else(|e| e.into_inner());
        alert_guard.stop_monitoring().await?;

        Ok(())
    }

    // Private helper methods
    async fn start_analytics_engines(&self) -> DeviceResult<()> {
        // Implementation will be in the analytics module
        Ok(())
    }

    async fn stop_analytics_engines(&self) -> DeviceResult<()> {
        // Implementation will be in the analytics module
        Ok(())
    }
}

impl Default for DashboardState {
    fn default() -> Self {
        Self {
            current_view: DashboardView::Overview,
            filters: Vec::new(),
            time_range: TimeRange {
                start: SystemTime::now() - Duration::from_secs(3600), // Last hour
                end: SystemTime::now(),
            },
            aggregation_level: AggregationLevel::Minute,
            refresh_enabled: true,
            last_update: SystemTime::now(),
        }
    }
}

impl TimeRange {
    /// Create a new time range for the last N seconds
    pub fn last_seconds(seconds: u64) -> Self {
        let now = SystemTime::now();
        Self {
            start: now - Duration::from_secs(seconds),
            end: now,
        }
    }

    /// Create a new time range for the last N minutes
    pub fn last_minutes(minutes: u64) -> Self {
        Self::last_seconds(minutes * 60)
    }

    /// Create a new time range for the last N hours
    pub fn last_hours(hours: u64) -> Self {
        Self::last_seconds(hours * 3600)
    }
}