optirs-learned 0.3.1

// Analytics and monitoring system for optimization coordinator
//
// This module provides comprehensive analytics capabilities for optimization monitoring,
// performance analysis, convergence detection, and reporting. The analytics system is
// built with a modular architecture for maintainability and extensibility.
//
// # Architecture
//
// The analytics system is organized into focused modules:
//
// - **config**: Configuration structures and core types
// - **performance**: Performance analysis and monitoring
// - **convergence**: Convergence detection and analysis
// - **resources**: Resource usage monitoring and optimization
// - **patterns**: Pattern detection and behavioral analysis
// - **anomalies**: Anomaly detection and alerting
// - **trends**: Trend analysis and forecasting
// - **reporting**: Report generation and visualization
// - **dashboard**: Real-time monitoring dashboard
//
// # Usage Example
//
// ```rust
// use optirs_core::learned_optimizers::optimization_coordinator::analytics::{
//     AnalyticsEngine, AnalyticsConfig
// };
//
// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
// // Create analytics configuration
// let config = AnalyticsConfig::default();
//
// // Create analytics engine
// let mut analytics = AnalyticsEngine::<f32>::new(config)?;
//
// // Start monitoring
// analytics.start_monitoring().await?;
// # Ok(())
// # }
// ```

use scirs2_core::numeric::Float;
use std::fmt::Debug;

pub mod config;
pub mod performance;
pub mod convergence;
pub mod resources;
pub mod patterns;

// Simplified modules for remaining functionality
pub mod anomalies {
    //! Anomaly detection for optimization processes

    use super::config::*;
    use crate::OptimizerError as OptimError;
    use scirs2_core::numeric::Float;
    use std::collections::VecDeque;
    use std::fmt::Debug;
    use std::time::SystemTime;

    /// Result type for anomaly operations
    type Result<T> = std::result::Result<T, OptimError>;

    /// Anomaly detector for optimization monitoring
    #[derive(Debug)]
    pub struct AnomalyDetector<T: Float + Debug + Send + Sync + 'static> {
        /// Configuration
        config: AnomalyDetectionConfig,
        /// Detection methods
        methods: Vec<AnomalyDetectionMethod>,
        /// Anomaly history
        anomaly_history: VecDeque<Anomaly<T>>,
        /// Current state
        current_state: AnomalyDetectionState<T>,
    }

    /// Detected anomaly
    #[derive(Debug, Clone)]
    pub struct Anomaly<T: Float + Debug + Send + Sync + 'static> {
        /// Anomaly timestamp
        pub timestamp: SystemTime,
        /// Anomaly score
        pub score: T,
        /// Anomaly type
        pub anomaly_type: AnomalyType,
        /// Description
        pub description: String,
        /// Severity
        pub severity: AlertSeverity,
    }

    /// Anomaly types
    #[derive(Debug, Clone, Copy)]
    pub enum AnomalyType {
        Statistical,
        Performance,
        Resource,
        Behavioral,
    }

    /// Anomaly detection state
    #[derive(Debug, Clone)]
    pub struct AnomalyDetectionState<T: Float + Debug + Send + Sync + 'static> {
        /// Detection enabled
        pub enabled: bool,
        /// Current threshold
        pub threshold: T,
        /// Recent anomalies
        pub recent_anomalies: usize,
    }

    impl<T: Float + Debug + Send + Sync + 'static + Default + Clone> AnomalyDetector<T> {
        /// Create new anomaly detector
        pub fn new(config: AnomalyDetectionConfig) -> Result<Self> {
            Ok(Self {
                config: config.clone(),
                methods: config.detection_methods,
                anomaly_history: VecDeque::new(),
                current_state: AnomalyDetectionState::default(),
            })
        }

        /// Detect anomalies in data
        pub fn detect_anomalies(&mut self, data: &[T]) -> Result<Vec<Anomaly<T>>> {
            let mut anomalies = Vec::new();

            for method in &self.methods {
                if let Some(anomaly) = self.detect_with_method(method, data)? {
                    anomalies.push(anomaly);
                }
            }

            // Update history
            for anomaly in &anomalies {
                self.anomaly_history.push_back(anomaly.clone());
                if self.anomaly_history.len() > 1000 {
                    self.anomaly_history.pop_front();
                }
            }

            Ok(anomalies)
        }

        /// Detect with specific method
        fn detect_with_method(&self, method: &AnomalyDetectionMethod, data: &[T]) -> Result<Option<Anomaly<T>>> {
            match method {
                AnomalyDetectionMethod::Statistical => {
                    if let Some(outlier) = self.detect_statistical_outlier(data)? {
                        Ok(Some(Anomaly {
                            timestamp: SystemTime::now(),
                            score: outlier,
                            anomaly_type: AnomalyType::Statistical,
                            description: "Statistical outlier detected".to_string(),
                            severity: AlertSeverity::Medium,
                        }))
                    } else {
                        Ok(None)
                    }
                },
                _ => Ok(None), // Simplified
            }
        }

        /// Detect statistical outliers
        fn detect_statistical_outlier(&self, data: &[T]) -> Result<Option<T>> {
            if data.len() < 3 {
                return Ok(None);
            }

            let mean = data.iter().fold(T::zero(), |acc, &x| acc + x) / T::from(data.len()).expect("unwrap failed");
            let variance = data.iter()
                .map(|&x| (x - mean) * (x - mean))
                .fold(T::zero(), |acc, x| acc + x) / T::from(data.len()).expect("unwrap failed");
            let std_dev = variance.sqrt();

            let last_value = data[data.len() - 1];
            let z_score = (last_value - mean) / std_dev;

            if z_score.abs() > scirs2_core::numeric::NumCast::from(3.0).unwrap_or_else(|| T::zero()) {
                Ok(Some(z_score.abs()))
            } else {
                Ok(None)
            }
        }

        /// Get anomaly history
        pub fn get_anomaly_history(&self) -> &VecDeque<Anomaly<T>> {
            &self.anomaly_history
        }
    }

    impl<T: Float + Debug + Send + Sync + 'static> Default for AnomalyDetectionState<T> {
        fn default() -> Self {
            Self {
                enabled: true,
                threshold: T::from(0.95).unwrap_or(T::zero()),
                recent_anomalies: 0,
            }
        }
    }
}

pub mod trends {
    //! Trend analysis and forecasting for optimization

    use super::config::*;
    use crate::OptimizerError as OptimError;
    use scirs2_core::numeric::Float;
    use std::collections::VecDeque;
    use std::fmt::Debug;
    use std::time::{Duration, SystemTime};

    /// Result type for trend operations
    type Result<T> = std::result::Result<T, OptimError>;

    /// Trend analyzer for optimization monitoring
    #[derive(Debug)]
    pub struct TrendAnalyzer<T: Float + Debug + Send + Sync + 'static> {
        /// Configuration
        config: TrendAnalysisConfig,
        /// Forecasting models
        models: Vec<ForecastingModel<T>>,
        /// Trend history
        trend_history: VecDeque<TrendAnalysis<T>>,
        /// Current trend state
        current_state: TrendState<T>,
    }

    /// Forecasting model
    #[derive(Debug)]
    pub struct ForecastingModel<T: Float + Debug + Send + Sync + 'static> {
        /// Model type
        pub model_type: ForecastingMethod,
        /// Model parameters
        pub parameters: Vec<T>,
        /// Prediction accuracy
        pub accuracy: T,
        /// Last update
        pub last_update: SystemTime,
    }

    /// Trend analysis result
    #[derive(Debug, Clone)]
    pub struct TrendAnalysis<T: Float + Debug + Send + Sync + 'static> {
        /// Analysis timestamp
        pub timestamp: SystemTime,
        /// Trend direction
        pub direction: TrendDirection,
        /// Trend strength
        pub strength: T,
        /// Predictions
        pub predictions: Vec<T>,
        /// Confidence intervals
        pub confidence_intervals: Vec<(T, T)>,
    }

    /// Trend direction
    #[derive(Debug, Clone, Copy)]
    pub enum TrendDirection {
        Upward,
        Downward,
        Stable,
        Oscillating,
    }

    /// Current trend state
    #[derive(Debug, Clone)]
    pub struct TrendState<T: Float + Debug + Send + Sync + 'static> {
        /// Current direction
        pub direction: TrendDirection,
        /// Trend strength
        pub strength: T,
        /// Duration
        pub duration: Duration,
        /// Reliability
        pub reliability: T,
    }

    impl<T: Float + Debug + Send + Sync + 'static + Default + Clone> TrendAnalyzer<T> {
        /// Create new trend analyzer
        pub fn new(config: TrendAnalysisConfig) -> Result<Self> {
            let mut models = Vec::new();

            for method in &config.forecasting_methods {
                models.push(ForecastingModel {
                    model_type: *method,
                    parameters: Vec::new(),
                    accuracy: T::from(0.8).unwrap_or(T::zero()),
                    last_update: SystemTime::now(),
                });
            }

            Ok(Self {
                config,
                models,
                trend_history: VecDeque::new(),
                current_state: TrendState::default(),
            })
        }

        /// Analyze trends in data
        pub fn analyze_trends(&mut self, data: &[T]) -> Result<TrendAnalysis<T>> {
            let direction = self.detect_trend_direction(data)?;
            let strength = self.calculate_trend_strength(data)?;
            let predictions = self.generate_predictions(data)?;

            let analysis = TrendAnalysis {
                timestamp: SystemTime::now(),
                direction,
                strength,
                predictions,
                confidence_intervals: Vec::new(), // Simplified
            };

            // Update history
            self.trend_history.push_back(analysis.clone());
            if self.trend_history.len() > 1000 {
                self.trend_history.pop_front();
            }

            // Update current state
            self.current_state.direction = direction;
            self.current_state.strength = strength;

            Ok(analysis)
        }

        /// Detect trend direction
        fn detect_trend_direction(&self, data: &[T]) -> Result<TrendDirection> {
            if data.len() < 2 {
                return Ok(TrendDirection::Stable);
            }

            let first_half = &data[..data.len()/2];
            let second_half = &data[data.len()/2..];

            let first_avg = first_half.iter().fold(T::zero(), |acc, &x| acc + x) / T::from(first_half.len()).expect("unwrap failed");
            let second_avg = second_half.iter().fold(T::zero(), |acc, &x| acc + x) / T::from(second_half.len()).expect("unwrap failed");

            let threshold = scirs2_core::numeric::NumCast::from(0.01).unwrap_or_else(|| T::zero());

            if second_avg > first_avg + threshold {
                Ok(TrendDirection::Upward)
            } else if second_avg < first_avg - threshold {
                Ok(TrendDirection::Downward)
            } else {
                Ok(TrendDirection::Stable)
            }
        }

        /// Calculate trend strength
        fn calculate_trend_strength(&self, data: &[T]) -> Result<T> {
            if data.len() < 2 {
                return Ok(T::zero());
            }

            let mut total_change = T::zero();
            for window in data.windows(2) {
                total_change = total_change + (window[1] - window[0]).abs();
            }

            Ok(total_change / T::from(data.len() - 1).expect("unwrap failed"))
        }

        /// Generate predictions
        fn generate_predictions(&self, data: &[T]) -> Result<Vec<T>> {
            if data.is_empty() {
                return Ok(Vec::new());
            }

            let last_value = data[data.len() - 1];
            let mut predictions = Vec::new();

            // Simple linear extrapolation
            for i in 1..=self.config.prediction_horizon {
                let predicted = last_value + scirs2_core::numeric::NumCast::from(i).unwrap_or_else(|| T::zero()) * scirs2_core::numeric::NumCast::from(0.01).unwrap_or_else(|| T::zero());
                predictions.push(predicted);
            }

            Ok(predictions)
        }

        /// Get trend history
        pub fn get_trend_history(&self) -> &VecDeque<TrendAnalysis<T>> {
            &self.trend_history
        }

        /// Get current trend state
        pub fn get_current_state(&self) -> &TrendState<T> {
            &self.current_state
        }
    }

    impl<T: Float + Debug + Send + Sync + 'static> Default for TrendState<T> {
        fn default() -> Self {
            Self {
                direction: TrendDirection::Stable,
                strength: T::zero(),
                duration: Duration::from_secs(0),
                reliability: T::from(0.5).unwrap_or(T::zero()),
            }
        }
    }
}

pub mod reporting {
    //! Report generation and visualization

    use super::config::*;
    use crate::OptimizerError as OptimError;
    use scirs2_core::numeric::Float;
    use std::collections::HashMap;
    use std::fmt::Debug;
    use std::time::SystemTime;

    /// Result type for reporting operations
    type Result<T> = std::result::Result<T, OptimError>;

    /// Report generator
    #[derive(Debug)]
    pub struct ReportGenerator<T: Float + Debug + Send + Sync + 'static> {
        /// Configuration
        config: ReportingConfig,
        /// Report templates
        templates: HashMap<String, ReportTemplate>,
        /// Generated reports
        report_history: Vec<GeneratedReport<T>>,
    }

    /// Report template
    #[derive(Debug, Clone)]
    pub struct ReportTemplate {
        /// Template name
        pub name: String,
        /// Template sections
        pub sections: Vec<ReportSection>,
        /// Output format
        pub format: ReportFormat,
    }

    /// Report section
    #[derive(Debug, Clone)]
    pub struct ReportSection {
        /// Section title
        pub title: String,
        /// Section type
        pub section_type: SectionType,
        /// Content
        pub content: String,
    }

    /// Section types
    #[derive(Debug, Clone)]
    pub enum SectionType {
        Summary,
        Chart,
        Table,
        Text,
        Metrics,
    }

    /// Generated report
    #[derive(Debug, Clone)]
    pub struct GeneratedReport<T: Float + Debug + Send + Sync + 'static> {
        /// Report ID
        pub id: String,
        /// Generation timestamp
        pub timestamp: SystemTime,
        /// Report content
        pub content: String,
        /// Format
        pub format: ReportFormat,
        /// Metrics included
        pub metrics: HashMap<String, T>,
    }

    impl<T: Float + Debug + Send + Sync + 'static + Default + Clone> ReportGenerator<T> {
        /// Create new report generator
        pub fn new(config: ReportingConfig) -> Result<Self> {
            Ok(Self {
                config,
                templates: HashMap::new(),
                report_history: Vec::new(),
            })
        }

        /// Generate report
        pub fn generate_report(&mut self, template_name: &str, data: &HashMap<String, T>) -> Result<GeneratedReport<T>> {
            let report = GeneratedReport {
                id: format!("report_{}", SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).expect("unwrap failed").as_secs()),
                timestamp: SystemTime::now(),
                content: "Generated report content".to_string(),
                format: ReportFormat::Html,
                metrics: data.clone(),
            };

            self.report_history.push(report.clone());
            Ok(report)
        }

        /// Get report history
        pub fn get_report_history(&self) -> &[GeneratedReport<T>] {
            &self.report_history
        }
    }
}

pub mod dashboard {
    //! Real-time monitoring dashboard

    use super::config::*;
    use crate::OptimizerError as OptimError;
    use scirs2_core::numeric::Float;
    use std::collections::HashMap;
    use std::fmt::Debug;
    use std::time::{Duration, SystemTime};

    /// Result type for dashboard operations
    type Result<T> = std::result::Result<T, OptimError>;

    /// Real-time dashboard
    #[derive(Debug)]
    pub struct RealTimeDashboard<T: Float + Debug + Send + Sync + 'static> {
        /// Configuration
        config: DashboardConfig,
        /// Dashboard panels
        panels: HashMap<String, DashboardPanel<T>>,
        /// Current data
        current_data: HashMap<String, T>,
        /// Update frequency
        update_frequency: Duration,
        /// Last update
        last_update: SystemTime,
    }

    /// Dashboard panel
    #[derive(Debug, Clone)]
    pub struct DashboardPanel<T: Float + Debug + Send + Sync + 'static> {
        /// Panel ID
        pub id: String,
        /// Panel title
        pub title: String,
        /// Panel type
        pub panel_type: PanelType,
        /// Current value
        pub current_value: T,
        /// Historical data
        pub historical_data: Vec<T>,
        /// Update timestamp
        pub last_update: SystemTime,
    }

    impl<T: Float + Debug + Send + Sync + 'static + Default + Clone> RealTimeDashboard<T> {
        /// Create new dashboard
        pub fn new(config: DashboardConfig) -> Result<Self> {
            Ok(Self {
                config: config.clone(),
                panels: HashMap::new(),
                current_data: HashMap::new(),
                update_frequency: config.update_frequency,
                last_update: SystemTime::now(),
            })
        }

        /// Update dashboard data
        pub fn update_data(&mut self, data: HashMap<String, T>) -> Result<()> {
            self.current_data.extend(data);
            self.last_update = SystemTime::now();

            // Update panels
            for (key, value) in &self.current_data {
                if let Some(panel) = self.panels.get_mut(key) {
                    panel.current_value = *value;
                    panel.historical_data.push(*value);
                    panel.last_update = SystemTime::now();

                    // Limit historical data
                    if panel.historical_data.len() > 1000 {
                        panel.historical_data.remove(0);
                    }
                }
            }

            Ok(())
        }

        /// Add panel to dashboard
        pub fn add_panel(&mut self, panel: DashboardPanel<T>) -> Result<()> {
            self.panels.insert(panel.id.clone(), panel);
            Ok(())
        }

        /// Get current dashboard state
        pub fn get_dashboard_state(&self) -> DashboardState<T> {
            DashboardState {
                panels: self.panels.clone(),
                last_update: self.last_update,
                update_frequency: self.update_frequency,
            }
        }
    }

    /// Dashboard state
    #[derive(Debug, Clone)]
    pub struct DashboardState<T: Float + Debug + Send + Sync + 'static> {
        /// Current panels
        pub panels: HashMap<String, DashboardPanel<T>>,
        /// Last update time
        pub last_update: SystemTime,
        /// Update frequency
        pub update_frequency: Duration,
    }
}

// Re-export main analytics engine and core types
pub use config::*;
pub use performance::{
    PerformanceAnalyzer, PerformanceSnapshot, PerformanceMetrics, PerformanceContext
};
pub use resources::{
    ResourceMonitor, ResourceUsage as ResourceUtilization, ResourceAlert, ResourceAnalyzer
};
pub use convergence::*;
pub use patterns::*;
pub use anomalies::*;
pub use trends::*;
pub use reporting::*;
pub use dashboard::*;

/// Main analytics engine coordinating all analysis components
#[derive(Debug)]
pub struct AnalyticsEngine<T: Float + Debug + Send + Sync + 'static> {
    /// Configuration
    pub config: AnalyticsConfig,

    /// Performance analyzer
    pub performance_analyzer: PerformanceAnalyzer<T>,

    /// Convergence analyzer
    pub convergence_analyzer: ConvergenceAnalyzer<T>,

    /// Resource analyzer
    pub resource_analyzer: ResourceAnalyzer<T>,

    /// Pattern detector
    pub pattern_detector: PatternDetector<T>,

    /// Anomaly detector
    pub anomaly_detector: AnomalyDetector<T>,

    /// Trend analyzer
    pub trend_analyzer: TrendAnalyzer<T>,

    /// Report generator
    pub report_generator: ReportGenerator<T>,

    /// Real-time dashboard
    pub dashboard: RealTimeDashboard<T>,
}

impl<T: Float + Debug + Send + Sync + 'static + Default + Clone> AnalyticsEngine<T> {
    /// Create new analytics engine
    pub fn new(config: AnalyticsConfig) -> crate::error::Result<Self> {
        Ok(Self {
            performance_analyzer: PerformanceAnalyzer::new(config.performance_config.clone())
                .map_err(|e| crate::error::OptimError::AnalyticsError(format!("Performance analyzer: {}", e)))?,
            convergence_analyzer: ConvergenceAnalyzer::new(config.convergence_config.clone())
                .map_err(|e| crate::error::OptimError::AnalyticsError(format!("Convergence analyzer: {}", e)))?,
            resource_analyzer: ResourceAnalyzer::new(config.resource_config.clone())
                .map_err(|e| crate::error::OptimError::AnalyticsError(format!("Resource analyzer: {}", e)))?,
            pattern_detector: PatternDetector::new(config.pattern_config.clone())
                .map_err(|e| crate::error::OptimError::AnalyticsError(format!("Pattern detector: {}", e)))?,
            anomaly_detector: AnomalyDetector::new(config.anomaly_config.clone())
                .map_err(|e| crate::error::OptimError::AnalyticsError(format!("Anomaly detector: {}", e)))?,
            trend_analyzer: TrendAnalyzer::new(config.trend_config.clone())
                .map_err(|e| crate::error::OptimError::AnalyticsError(format!("Trend analyzer: {}", e)))?,
            report_generator: ReportGenerator::new(config.reporting_config.clone())
                .map_err(|e| crate::error::OptimError::AnalyticsError(format!("Report generator: {}", e)))?,
            dashboard: RealTimeDashboard::new(config.dashboard_config.clone())
                .map_err(|e| crate::error::OptimError::AnalyticsError(format!("Dashboard: {}", e)))?,
            config,
        })
    }

    /// Process performance snapshot
    pub fn process_snapshot(&mut self, snapshot: PerformanceSnapshot<T>) -> crate::error::Result<AnalysisResult<T>> {
        // Record performance data
        self.performance_analyzer.record_snapshot(snapshot.clone())
            .map_err(|e| crate::error::OptimError::AnalyticsError(format!("Performance recording: {}", e)))?;

        // Analyze convergence
        let convergence_analysis = self.convergence_analyzer.analyze_convergence(&snapshot)
            .map_err(|e| crate::error::OptimError::AnalyticsError(format!("Convergence analysis: {}", e)))?;

        // Detect patterns
        let patterns = self.pattern_detector.detect_patterns(&snapshot)
            .map_err(|e| crate::error::OptimError::AnalyticsError(format!("Pattern detection: {}", e)))?;

        // Update dashboard
        let mut dashboard_data = std::collections::HashMap::new();
        dashboard_data.insert("loss".to_string(), snapshot.loss);
        if let Some(accuracy) = snapshot.accuracy {
            dashboard_data.insert("accuracy".to_string(), accuracy);
        }

        self.dashboard.update_data(dashboard_data)
            .map_err(|e| crate::error::OptimError::AnalyticsError(format!("Dashboard update: {}", e)))?;

        Ok(AnalysisResult {
            timestamp: std::time::SystemTime::now(),
            performance_metrics: snapshot.metrics,
            convergence_analysis,
            detected_patterns: patterns,
            anomalies: Vec::new(), // Simplified
            trends: Vec::new(),    // Simplified
        })
    }

    /// Start monitoring (async placeholder)
    pub async fn start_monitoring(&mut self) -> crate::error::Result<()> {
        // Placeholder for async monitoring logic
        Ok(())
    }

    /// Generate comprehensive report
    pub fn generate_report(&mut self) -> crate::error::Result<String> {
        let mut data = std::collections::HashMap::new();
        data.insert("total_snapshots".to_string(), T::from(self.performance_analyzer.get_performance_history().len()).unwrap_or(T::zero()));

        let report = self.report_generator.generate_report("comprehensive", &data)
            .map_err(|e| crate::error::OptimError::AnalyticsError(format!("Report generation: {}", e)))?;

        Ok(report.content)
    }
}

/// Analysis result combining all analytics components
#[derive(Debug, Clone)]
pub struct AnalysisResult<T: Float + Debug + Send + Sync + 'static> {
    /// Analysis timestamp
    pub timestamp: std::time::SystemTime,

    /// Performance metrics
    pub performance_metrics: PerformanceMetrics<T>,

    /// Convergence analysis
    pub convergence_analysis: ConvergenceAnalysis<T>,

    /// Detected patterns
    pub detected_patterns: Vec<DetectedPattern<T>>,

    /// Detected anomalies
    pub anomalies: Vec<Anomaly<T>>,

    /// Trend analysis
    pub trends: Vec<TrendAnalysis<T>>,
}

/// Convenience function to create default analytics engine
pub fn create_default_analytics_engine<T: Float + Debug + Send + Sync + 'static + Default + Clone>()
    -> crate::error::Result<AnalyticsEngine<T>> {
    let config = AnalyticsConfig::default();
    AnalyticsEngine::new(config)
}

/// Convenience function to create analytics engine for performance monitoring
pub fn create_performance_analytics_engine<T: Float + Debug + Send + Sync + 'static + Default + Clone>()
    -> crate::error::Result<AnalyticsEngine<T>> {
    let mut config = AnalyticsConfig::default();
    config.enable_performance_monitoring = true;
    config.enable_convergence_analysis = true;
    config.enable_pattern_detection = true;
    config.enable_dashboard = true;

    AnalyticsEngine::new(config)
}

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

    #[test]
    fn test_analytics_engine_creation() {
        let config = AnalyticsConfig::default();
        let engine = AnalyticsEngine::<f32>::new(config);
        assert!(engine.is_ok());
    }

    #[test]
    fn test_convenience_functions() {
        let engine = create_default_analytics_engine::<f32>();
        assert!(engine.is_ok());

        let perf_engine = create_performance_analytics_engine::<f32>();
        assert!(perf_engine.is_ok());
    }

    #[test]
    fn test_analysis_result() {
        let result = AnalysisResult {
            timestamp: std::time::SystemTime::now(),
            performance_metrics: PerformanceMetrics::default(),
            convergence_analysis: ConvergenceAnalysis {
                timestamp: std::time::SystemTime::now(),
                step: 100,
                detections: Vec::new(),
                consensus: ConvergenceConsensus::default(),
                summary: ConvergenceAnalysisSummary {
                    estimated_convergence_time: None,
                    convergence_quality: 0.8,
                    stability_assessment: StabilityAssessment {
                        loss_stability: 0.9,
                        gradient_stability: 0.8,
                        parameter_stability: 0.85,
                        overall_stability: 0.85,
                        stability_trend: StabilityTrend::Stable,
                    },
                    performance_trajectory: TrajectoryAnalysis {
                        trajectory_type: TrajectoryType::Monotonic,
                        convergence_rate: 0.05,
                        trajectory_smoothness: 0.8,
                        phase_transitions: Vec::new(),
                    },
                },
                recommendations: Vec::new(),
            },
            detected_patterns: Vec::new(),
            anomalies: Vec::new(),
            trends: Vec::new(),
        };

        // Verify the result can be created and has expected structure
        assert!(!result.detected_patterns.is_empty() || result.detected_patterns.is_empty()); // Just a compilation check
    }
}