quantrs2-tytan 0.1.3

//! Analytics types for Real-time Quantum Computing Integration
//!
//! This module provides performance analytics, metrics collection, and anomaly detection types.

use serde::{Deserialize, Serialize};
use std::collections::{BTreeMap, HashMap, VecDeque};
use std::time::{Duration, SystemTime};

use super::config::RealtimeConfig;
use super::metrics::DeviceMetrics;
use super::resource::PredictionModel;
use super::types::{
    AggregationFunction, AlertChannel, AnalyticsModelType, AnomalyDetectionAlgorithm, AnomalyType,
    AuthenticationType, AxisScale, BackoffStrategy, CollectionMethod, ColorScheme,
    CompressionAlgorithm, DataFormat, DataSourceType, EnsembleMethod, FeatureTransformation,
    FilterOperator, IndexType, IssueSeverity, JobPriority, LegendOrientation, LegendPosition,
    MetricDataType, WidgetType,
};

/// Real-time performance analytics engine
pub struct PerformanceAnalytics {
    /// Metrics collector
    pub(crate) metrics_collector: MetricsCollector,
    /// Analytics models
    pub(crate) analytics_models: HashMap<String, AnalyticsModel>,
    /// Real-time dashboard
    pub(crate) dashboard: RealtimeDashboard,
    /// Performance predictor
    pub(crate) performance_predictor: PerformancePredictor,
    /// Anomaly detector
    pub(crate) anomaly_detector: AnomalyDetector,
}

impl PerformanceAnalytics {
    pub fn new(_config: &RealtimeConfig) -> Self {
        Self {
            metrics_collector: MetricsCollector::new(),
            analytics_models: HashMap::new(),
            dashboard: RealtimeDashboard::new(),
            performance_predictor: PerformancePredictor::new(),
            anomaly_detector: AnomalyDetector::new(),
        }
    }

    pub const fn update_analytics(&mut self) -> Result<(), String> {
        // Update analytics models and predictions
        Ok(())
    }

    pub fn get_current_metrics(&self) -> Result<RealtimeMetrics, String> {
        Ok(RealtimeMetrics {
            timestamp: SystemTime::now(),
            system_metrics: SystemMetrics {
                health_score: 0.85,
                total_devices: 5,
                active_devices: 4,
                total_jobs_processed: 1000,
                current_load: 0.6,
            },
            device_metrics: HashMap::new(),
            queue_metrics: QueueMetrics {
                total_queued_jobs: 25,
                jobs_by_priority: {
                    let mut map = HashMap::new();
                    map.insert(JobPriority::High, 5);
                    map.insert(JobPriority::Normal, 15);
                    map.insert(JobPriority::Low, 5);
                    map
                },
                average_wait_time: Duration::from_secs(300),
                throughput: 10.0,
            },
            performance_metrics: SystemPerformanceMetrics {
                performance_score: 0.88,
                latency_stats: LatencyStats {
                    average: Duration::from_millis(250),
                    median: Duration::from_millis(200),
                    p95: Duration::from_millis(500),
                    p99: Duration::from_millis(1000),
                },
                throughput_stats: ThroughputStats {
                    requests_per_second: 100.0,
                    jobs_per_hour: 50.0,
                    data_per_second: 1024.0,
                },
                error_stats: ErrorStats {
                    total_errors: 10,
                    error_rate: 0.01,
                    errors_by_type: HashMap::new(),
                },
            },
        })
    }
}

/// Metrics collector
#[derive(Debug, Clone)]
pub struct MetricsCollector {
    /// Active metrics
    pub(crate) active_metrics: HashMap<String, MetricDefinition>,
    /// Collection intervals
    pub(crate) collection_intervals: HashMap<String, Duration>,
    /// Data storage
    pub(crate) data_storage: MetricsStorage,
    /// Aggregation rules
    pub(crate) aggregation_rules: Vec<AggregationRule>,
}

impl Default for MetricsCollector {
    fn default() -> Self {
        Self::new()
    }
}

impl MetricsCollector {
    pub fn new() -> Self {
        Self {
            active_metrics: HashMap::new(),
            collection_intervals: HashMap::new(),
            data_storage: MetricsStorage {
                time_series_db: HashMap::new(),
                indexes: HashMap::new(),
                storage_stats: StorageStatistics {
                    total_data_points: 0,
                    storage_size_bytes: 0,
                    compression_ratio: 1.0,
                    query_performance: QueryPerformanceStats {
                        average_query_time: Duration::from_millis(10),
                        cache_hit_rate: 0.8,
                        index_efficiency: 0.9,
                    },
                },
            },
            aggregation_rules: vec![],
        }
    }
}

/// Metric definition
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MetricDefinition {
    /// Metric name
    pub name: String,
    /// Metric type
    pub metric_type: MetricDataType,
    /// Units
    pub units: String,
    /// Description
    pub description: String,
    /// Collection method
    pub collection_method: CollectionMethod,
    /// Retention policy
    pub retention_policy: RetentionPolicy,
}

/// Data retention policy
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RetentionPolicy {
    /// Raw data retention
    pub raw_retention: Duration,
    /// Aggregated data retention
    pub aggregated_retention: Duration,
    /// Compression settings
    pub compression: CompressionSettings,
}

/// Compression settings for data storage
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CompressionSettings {
    /// Enable compression
    pub enabled: bool,
    /// Compression algorithm
    pub algorithm: CompressionAlgorithm,
    /// Compression ratio target
    pub ratio_target: f64,
}

/// Metrics storage
#[derive(Debug, Clone)]
pub struct MetricsStorage {
    /// Time series database
    pub(crate) time_series_db: HashMap<String, VecDeque<DataPoint>>,
    /// Indexes
    pub(crate) indexes: HashMap<String, Index>,
    /// Storage statistics
    pub(crate) storage_stats: StorageStatistics,
}

/// Data point for time series
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DataPoint {
    /// Timestamp
    pub timestamp: SystemTime,
    /// Value
    pub value: f64,
    /// Tags
    pub tags: HashMap<String, String>,
    /// Metadata
    pub metadata: Option<HashMap<String, String>>,
}

/// Index for efficient querying
#[derive(Debug, Clone)]
pub struct Index {
    /// Index type
    pub index_type: IndexType,
    /// Index data
    pub index_data: BTreeMap<String, Vec<usize>>,
    /// Last update
    pub last_update: SystemTime,
}

/// Storage statistics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StorageStatistics {
    /// Total data points
    pub total_data_points: usize,
    /// Storage size (bytes)
    pub storage_size_bytes: usize,
    /// Compression ratio
    pub compression_ratio: f64,
    /// Query performance
    pub query_performance: QueryPerformanceStats,
}

/// Query performance statistics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QueryPerformanceStats {
    /// Average query time
    pub average_query_time: Duration,
    /// Query cache hit rate
    pub cache_hit_rate: f64,
    /// Index efficiency
    pub index_efficiency: f64,
}

/// Aggregation rule for metrics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AggregationRule {
    /// Rule name
    pub name: String,
    /// Source metrics
    pub source_metrics: Vec<String>,
    /// Aggregation function
    pub aggregation_function: AggregationFunction,
    /// Time window
    pub time_window: Duration,
    /// Output metric name
    pub output_metric: String,
}

/// Analytics model
#[derive(Debug, Clone)]
pub struct AnalyticsModel {
    /// Model name
    pub model_name: String,
    /// Model type
    pub model_type: AnalyticsModelType,
    /// Model parameters
    pub parameters: HashMap<String, f64>,
    /// Training data
    pub training_data: VecDeque<DataPoint>,
    /// Model performance
    pub performance_metrics: ModelPerformanceMetrics,
}

/// Model performance metrics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ModelPerformanceMetrics {
    /// Accuracy
    pub accuracy: f64,
    /// Precision
    pub precision: f64,
    /// Recall
    pub recall: f64,
    /// F1 score
    pub f1_score: f64,
    /// Mean squared error
    pub mse: f64,
    /// Mean absolute error
    pub mae: f64,
}

/// Real-time dashboard
#[derive(Debug, Clone)]
pub struct RealtimeDashboard {
    /// Dashboard widgets
    pub(crate) widgets: Vec<DashboardWidget>,
    /// Update frequency
    pub(crate) update_frequency: Duration,
    /// Data sources
    pub(crate) data_sources: Vec<DataSource>,
    /// User preferences
    pub(crate) user_preferences: UserPreferences,
}

impl Default for RealtimeDashboard {
    fn default() -> Self {
        Self::new()
    }
}

impl RealtimeDashboard {
    pub fn new() -> Self {
        Self {
            widgets: vec![],
            update_frequency: Duration::from_secs(5),
            data_sources: vec![],
            user_preferences: UserPreferences {
                theme: "dark".to_string(),
                default_time_range: TimeRange::Last(Duration::from_secs(3600)),
                auto_refresh_interval: Duration::from_secs(30),
                notification_settings: NotificationSettings {
                    enabled: true,
                    channels: vec![AlertChannel::Dashboard],
                    preferences: HashMap::new(),
                },
            },
        }
    }
}

/// Dashboard widget
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DashboardWidget {
    /// Widget ID
    pub widget_id: String,
    /// Widget type
    pub widget_type: WidgetType,
    /// Data query
    pub data_query: DataQuery,
    /// Display settings
    pub display_settings: DisplaySettings,
    /// Position and size
    pub layout: WidgetLayout,
}

/// Data query for widgets
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DataQuery {
    /// Metrics to query
    pub metrics: Vec<String>,
    /// Time range
    pub time_range: TimeRange,
    /// Filters
    pub filters: Vec<QueryFilter>,
    /// Aggregation
    pub aggregation: Option<AggregationFunction>,
}

/// Time range for queries
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum TimeRange {
    Last(Duration),
    Range { start: SystemTime, end: SystemTime },
    RealTime,
}

/// Query filter
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QueryFilter {
    /// Field name
    pub field: String,
    /// Operator
    pub operator: FilterOperator,
    /// Value
    pub value: String,
}

/// Display settings for widgets
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DisplaySettings {
    /// Title
    pub title: String,
    /// Color scheme
    pub color_scheme: ColorScheme,
    /// Axes settings
    pub axes_settings: AxesSettings,
    /// Legend settings
    pub legend_settings: LegendSettings,
}

/// Axes settings for charts
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AxesSettings {
    /// X-axis label
    pub x_label: Option<String>,
    /// Y-axis label
    pub y_label: Option<String>,
    /// X-axis scale
    pub x_scale: AxisScale,
    /// Y-axis scale
    pub y_scale: AxisScale,
}

/// Legend settings for charts
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LegendSettings {
    /// Show legend
    pub show: bool,
    /// Position
    pub position: LegendPosition,
    /// Orientation
    pub orientation: LegendOrientation,
}

/// Widget layout
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WidgetLayout {
    /// X position
    pub x: usize,
    /// Y position
    pub y: usize,
    /// Width
    pub width: usize,
    /// Height
    pub height: usize,
}

/// Data source configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DataSource {
    /// Source ID
    pub source_id: String,
    /// Source type
    pub source_type: DataSourceType,
    /// Connection settings
    pub connection_settings: ConnectionSettings,
    /// Data format
    pub data_format: DataFormat,
}

/// Connection settings for data sources
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ConnectionSettings {
    /// URL or endpoint
    pub endpoint: String,
    /// Authentication
    pub authentication: Option<AuthenticationInfo>,
    /// Connection timeout
    pub timeout: Duration,
    /// Retry policy
    pub retry_policy: RetryPolicy,
}

/// Authentication information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AuthenticationInfo {
    /// Auth type
    pub auth_type: AuthenticationType,
    /// Credentials
    pub credentials: HashMap<String, String>,
}

/// Retry policy for connections
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RetryPolicy {
    /// Maximum retries
    pub max_retries: usize,
    /// Retry delay
    pub retry_delay: Duration,
    /// Backoff strategy
    pub backoff_strategy: BackoffStrategy,
}

/// User preferences for dashboard
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UserPreferences {
    /// Theme
    pub theme: String,
    /// Default time range
    pub default_time_range: TimeRange,
    /// Auto-refresh interval
    pub auto_refresh_interval: Duration,
    /// Notification settings
    pub notification_settings: NotificationSettings,
}

/// Notification settings
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NotificationSettings {
    /// Enable notifications
    pub enabled: bool,
    /// Notification channels
    pub channels: Vec<AlertChannel>,
    /// Notification preferences
    pub preferences: HashMap<String, bool>,
}

/// Performance predictor
#[derive(Debug, Clone)]
pub struct PerformancePredictor {
    /// Prediction models
    pub(crate) prediction_models: HashMap<String, PredictionModel>,
    /// Feature extractors
    pub(crate) feature_extractors: Vec<FeatureExtractor>,
    /// Prediction cache
    pub(crate) prediction_cache: HashMap<String, PredictionResult>,
}

impl Default for PerformancePredictor {
    fn default() -> Self {
        Self::new()
    }
}

impl PerformancePredictor {
    pub fn new() -> Self {
        Self {
            prediction_models: HashMap::new(),
            feature_extractors: vec![],
            prediction_cache: HashMap::new(),
        }
    }
}

/// Feature extractor for predictions
#[derive(Debug, Clone)]
pub struct FeatureExtractor {
    /// Extractor name
    pub name: String,
    /// Input metrics
    pub input_metrics: Vec<String>,
    /// Feature transformation
    pub transformation: FeatureTransformation,
}

/// Prediction result
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PredictionResult {
    /// Predicted values
    pub predictions: Vec<f64>,
    /// Confidence intervals
    pub confidence_intervals: Vec<(f64, f64)>,
    /// Prediction timestamp
    pub timestamp: SystemTime,
    /// Model used
    pub model_name: String,
    /// Prediction horizon
    pub horizon: Duration,
}

/// Anomaly detector
#[derive(Debug, Clone)]
pub struct AnomalyDetector {
    /// Detection algorithms
    pub(crate) detection_algorithms: Vec<AnomalyDetectionAlgorithm>,
    /// Anomaly history
    pub(crate) anomaly_history: VecDeque<AnomalyEvent>,
    /// Detection thresholds
    pub(crate) detection_thresholds: HashMap<String, f64>,
    /// Model ensemble
    pub(crate) ensemble: AnomalyEnsemble,
}

impl Default for AnomalyDetector {
    fn default() -> Self {
        Self::new()
    }
}

impl AnomalyDetector {
    pub fn new() -> Self {
        Self {
            detection_algorithms: vec![
                AnomalyDetectionAlgorithm::StatisticalOutlier,
                AnomalyDetectionAlgorithm::IsolationForest,
            ],
            anomaly_history: VecDeque::new(),
            detection_thresholds: HashMap::new(),
            ensemble: AnomalyEnsemble {
                base_detectors: vec![],
                ensemble_method: EnsembleMethod::WeightedVoting,
                voting_weights: HashMap::new(),
            },
        }
    }
}

/// Anomaly event
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AnomalyEvent {
    /// Event timestamp
    pub timestamp: SystemTime,
    /// Anomaly type
    pub anomaly_type: AnomalyType,
    /// Severity
    pub severity: IssueSeverity,
    /// Affected metrics
    pub affected_metrics: Vec<String>,
    /// Anomaly score
    pub anomaly_score: f64,
    /// Description
    pub description: String,
    /// Root cause analysis
    pub root_cause: Option<RootCauseAnalysis>,
}

/// Root cause analysis
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RootCauseAnalysis {
    /// Probable causes
    pub probable_causes: Vec<ProbableCause>,
    /// Correlation analysis
    pub correlations: Vec<Correlation>,
    /// Recommendations
    pub recommendations: Vec<String>,
}

/// Probable cause for anomaly
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProbableCause {
    /// Cause description
    pub description: String,
    /// Probability
    pub probability: f64,
    /// Supporting evidence
    pub evidence: Vec<String>,
}

/// Correlation for root cause analysis
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Correlation {
    /// Correlated metric
    pub metric: String,
    /// Correlation coefficient
    pub coefficient: f64,
    /// Time lag
    pub time_lag: Duration,
}

/// Anomaly ensemble for detection
#[derive(Debug, Clone)]
pub struct AnomalyEnsemble {
    /// Base detectors
    pub(crate) base_detectors: Vec<AnomalyDetectionAlgorithm>,
    /// Ensemble method
    pub(crate) ensemble_method: EnsembleMethod,
    /// Voting weights
    pub(crate) voting_weights: HashMap<String, f64>,
}

// Real-time metrics types

/// Real-time metrics snapshot
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RealtimeMetrics {
    /// Current timestamp
    pub timestamp: SystemTime,
    /// System metrics
    pub system_metrics: SystemMetrics,
    /// Device metrics
    pub device_metrics: HashMap<String, DeviceMetrics>,
    /// Queue metrics
    pub queue_metrics: QueueMetrics,
    /// Performance metrics
    pub performance_metrics: SystemPerformanceMetrics,
}

/// System-wide metrics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SystemMetrics {
    /// Overall health score
    pub health_score: f64,
    /// Total devices
    pub total_devices: usize,
    /// Active devices
    pub active_devices: usize,
    /// Total jobs processed
    pub total_jobs_processed: usize,
    /// Current load
    pub current_load: f64,
}

/// Queue metrics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QueueMetrics {
    /// Total queued jobs
    pub total_queued_jobs: usize,
    /// Jobs by priority
    pub jobs_by_priority: HashMap<JobPriority, usize>,
    /// Average wait time
    pub average_wait_time: Duration,
    /// Queue throughput
    pub throughput: f64,
}

/// System performance metrics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SystemPerformanceMetrics {
    /// Overall performance score
    pub performance_score: f64,
    /// Latency statistics
    pub latency_stats: LatencyStats,
    /// Throughput statistics
    pub throughput_stats: ThroughputStats,
    /// Error statistics
    pub error_stats: ErrorStats,
}

/// Latency statistics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LatencyStats {
    /// Average latency
    pub average: Duration,
    /// Median latency
    pub median: Duration,
    /// 95th percentile
    pub p95: Duration,
    /// 99th percentile
    pub p99: Duration,
}

/// Throughput statistics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ThroughputStats {
    /// Requests per second
    pub requests_per_second: f64,
    /// Jobs per hour
    pub jobs_per_hour: f64,
    /// Data processed per second
    pub data_per_second: f64,
}

/// Error statistics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ErrorStats {
    /// Total errors
    pub total_errors: usize,
    /// Error rate
    pub error_rate: f64,
    /// Errors by type
    pub errors_by_type: HashMap<String, usize>,
}