quantrs2-device 0.1.3

//! Storage and historical data management types for enhanced monitoring

use super::components::*;
use super::types::*;
use chrono::{DateTime, Duration as ChronoDuration, Utc};
use serde::{Deserialize, Serialize};
use std::collections::{BTreeMap, HashMap, HashSet, VecDeque};
use std::sync::{Arc, Mutex, RwLock};
use std::time::Duration;
use uuid::Uuid;

use crate::quantum_network::network_optimization::Priority;

/// Historical data manager for quantum networks
#[derive(Debug)]
pub struct QuantumHistoricalDataManager {
    /// Time-series database interface
    pub time_series_db: Arc<TimeSeriesDatabase>,
    /// Data retention manager
    pub retention_manager: Arc<DataRetentionManager>,
    /// Data compression system
    pub compression_system: Arc<DataCompressionSystem>,
    /// Historical analytics engine
    pub historical_analytics: Arc<HistoricalAnalyticsEngine>,
    /// Data export system
    pub export_system: Arc<DataExportSystem>,
}

/// Analytics engine configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AnalyticsEngineConfig {
    /// Enable real-time analytics
    pub real_time_analytics: bool,
    /// Pattern recognition settings
    pub pattern_recognition: PatternRecognitionConfig,
    /// Correlation analysis settings
    pub correlation_analysis: CorrelationAnalysisConfig,
    /// Trend analysis settings
    pub trend_analysis: TrendAnalysisConfig,
    /// Performance modeling settings
    pub performance_modeling: PerformanceModelingConfig,
}

/// Pattern recognition configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PatternRecognitionConfig {
    /// Enable pattern recognition
    pub enabled: bool,
    /// Pattern types to detect
    pub pattern_types: Vec<PatternType>,
    /// Pattern detection sensitivity
    pub sensitivity: f64,
    /// Minimum pattern duration
    pub min_pattern_duration: Duration,
}

/// Types of patterns to recognize
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum PatternType {
    /// Periodic patterns
    Periodic,
    /// Trending patterns
    Trending,
    /// Anomalous patterns
    Anomalous,
    /// Correlation patterns
    Correlation,
    /// Quantum-specific patterns
    QuantumSpecific,
}

/// Correlation analysis configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CorrelationAnalysisConfig {
    /// Enable correlation analysis
    pub enabled: bool,
    /// Correlation methods
    pub correlation_methods: Vec<CorrelationMethod>,
    /// Minimum correlation threshold
    pub min_correlation_threshold: f64,
    /// Analysis window size
    pub analysis_window: Duration,
}

/// Correlation analysis methods
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum CorrelationMethod {
    /// Pearson correlation
    Pearson,
    /// Spearman correlation
    Spearman,
    /// Kendall tau correlation
    KendallTau,
    /// Cross-correlation
    CrossCorrelation,
    /// Mutual information
    MutualInformation,
}

/// Trend analysis configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TrendAnalysisConfig {
    /// Enable trend analysis
    pub enabled: bool,
    /// Trend detection methods
    pub trend_methods: Vec<TrendMethod>,
    /// Trend detection sensitivity
    pub sensitivity: f64,
    /// Minimum trend duration
    pub min_trend_duration: Duration,
}

/// Trend detection methods
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum TrendMethod {
    /// Linear regression trend
    LinearRegression,
    /// Mann-Kendall test
    MannKendall,
    /// Sen's slope estimator
    SensSlope,
    /// Seasonal decomposition
    SeasonalDecomposition,
    /// Change point detection
    ChangePointDetection,
}

/// Performance modeling configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PerformanceModelingConfig {
    /// Enable performance modeling
    pub enabled: bool,
    /// Modeling algorithms
    pub modeling_algorithms: Vec<ModelingAlgorithm>,
    /// Model update frequency
    pub update_frequency: Duration,
    /// Model validation methods
    pub validation_methods: Vec<ValidationMethod>,
}

/// Performance modeling algorithms
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ModelingAlgorithm {
    /// Linear regression
    LinearRegression,
    /// Polynomial regression
    PolynomialRegression { degree: u32 },
    /// Support vector regression
    SupportVectorRegression,
    /// Random forest regression
    RandomForestRegression,
    /// Gradient boosting regression
    GradientBoostingRegression,
    /// Neural network regression
    NeuralNetworkRegression,
}

/// Model validation methods
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ValidationMethod {
    /// Cross-validation
    CrossValidation { folds: u32 },
    /// Time series split validation
    TimeSeriesSplit { n_splits: u32 },
    /// Hold-out validation
    HoldOut { test_size: f64 },
    /// Bootstrap validation
    Bootstrap { n_bootstraps: u32 },
}

/// Anomaly detection configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AnomalyDetectionConfig {
    /// Enable anomaly detection
    pub enabled: bool,
    /// Detection methods
    pub detection_methods: Vec<AnomalyModelType>,
    /// Detection sensitivity
    pub sensitivity: f64,
    /// Training data requirements
    pub training_requirements: TrainingRequirements,
}

/// Training requirements for anomaly detection
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TrainingRequirements {
    /// Minimum training data points
    pub min_training_points: u32,
    /// Training data window
    pub training_window: Duration,
    /// Retraining frequency
    pub retraining_frequency: Duration,
    /// Data quality requirements
    pub quality_requirements: DataQualityRequirements,
}

/// Data quality requirements
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DataQualityRequirements {
    /// Minimum data completeness
    pub min_completeness: f64,
    /// Maximum missing data percentage
    pub max_missing_percentage: f64,
    /// Minimum data accuracy
    pub min_accuracy: f64,
    /// Maximum outlier percentage
    pub max_outlier_percentage: f64,
}

/// Predictive analytics configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PredictiveAnalyticsConfig {
    /// Enable predictive analytics
    pub enabled: bool,
    /// Prediction horizons
    pub prediction_horizons: Vec<Duration>,
    /// Prediction models
    pub prediction_models: Vec<PredictionModelType>,
    /// Model selection criteria
    pub model_selection: ModelSelectionCriteria,
}

/// Model selection criteria
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ModelSelectionCriteria {
    /// Primary metric for model selection
    pub primary_metric: ModelSelectionMetric,
    /// Secondary metrics
    pub secondary_metrics: Vec<ModelSelectionMetric>,
    /// Cross-validation strategy
    pub cross_validation: CrossValidationStrategy,
}

/// Metrics for model selection
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ModelSelectionMetric {
    /// Mean absolute error
    MAE,
    /// Mean squared error
    MSE,
    /// Root mean squared error
    RMSE,
    /// Mean absolute percentage error
    MAPE,
    /// R-squared
    RSquared,
    /// Akaike information criterion
    AIC,
    /// Bayesian information criterion
    BIC,
}

/// Cross-validation strategies
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum CrossValidationStrategy {
    /// K-fold cross-validation
    KFold { k: u32 },
    /// Time series cross-validation
    TimeSeries { n_splits: u32, gap: Duration },
    /// Stratified cross-validation
    Stratified { n_splits: u32 },
    /// Leave-one-out cross-validation
    LeaveOneOut,
}

/// Alert system configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AlertSystemConfig {
    /// Enable alert system
    pub enabled: bool,
    /// Default alert rules
    pub default_rules: Vec<AlertRule>,
    /// Notification configuration
    pub notification_config: NotificationConfig,
    /// Escalation configuration
    pub escalation_config: EscalationConfig,
}

/// Notification configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NotificationConfig {
    /// Default notification channels
    pub default_channels: Vec<NotificationChannel>,
    /// Rate limiting settings
    pub rate_limiting: RateLimitingConfig,
    /// Message formatting settings
    pub message_formatting: MessageFormattingConfig,
}

/// Rate limiting configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RateLimitingConfig {
    /// Enable rate limiting
    pub enabled: bool,
    /// Rate limits per severity
    pub severity_limits: HashMap<AlertSeverity, FrequencyLimits>,
    /// Global rate limits
    pub global_limits: FrequencyLimits,
}

/// Message formatting configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MessageFormattingConfig {
    /// Include technical details
    pub include_technical_details: bool,
    /// Include recommendations
    pub include_recommendations: bool,
    /// Use markdown formatting
    pub use_markdown: bool,
    /// Custom message templates
    pub templates: HashMap<String, String>,
}

/// Escalation configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EscalationConfig {
    /// Enable automatic escalation
    pub auto_escalation_enabled: bool,
    /// Default escalation levels
    pub default_escalation_levels: Vec<EscalationLevel>,
    /// Escalation policies
    pub escalation_policies: Vec<EscalationPolicy>,
}

/// Escalation policy
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EscalationPolicy {
    /// Policy name
    pub policy_name: String,
    /// Policy conditions
    pub conditions: Vec<EscalationCondition>,
    /// Escalation actions
    pub actions: Vec<EscalationAction>,
}

/// Escalation actions
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum EscalationAction {
    /// Notify additional recipients
    NotifyAdditional { recipients: Vec<String> },
    /// Increase alert severity
    IncreaseSeverity { new_severity: AlertSeverity },
    /// Create incident ticket
    CreateIncident { ticket_system: String },
    /// Execute custom action
    CustomAction {
        action_name: String,
        parameters: HashMap<String, String>,
    },
}

/// Storage configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StorageConfig {
    /// Storage backend type
    pub backend_type: StorageBackendType,
    /// Data retention policies
    pub retention_policies: HashMap<MetricType, RetentionPolicy>,
    /// Compression settings
    pub compression: CompressionConfig,
    /// Backup settings
    pub backup: BackupConfig,
}

/// Storage backend types
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum StorageBackendType {
    /// In-memory storage (for testing)
    InMemory,
    /// Local file system
    LocalFileSystem { base_path: String },
    /// Time series database
    TimeSeriesDB { connection_string: String },
    /// Object storage (S3, etc.)
    ObjectStorage { endpoint: String, bucket: String },
    /// Distributed storage
    Distributed { nodes: Vec<String> },
}

/// Data retention policy
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RetentionPolicy {
    /// Raw data retention period
    pub raw_data_retention: Duration,
    /// Aggregated data retention period
    pub aggregated_data_retention: Duration,
    /// Archive after period
    pub archive_after: Duration,
    /// Delete after period
    pub delete_after: Duration,
}

/// Compression configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CompressionConfig {
    /// Enable compression
    pub enabled: bool,
    /// Compression algorithm
    pub algorithm: CompressionAlgorithm,
    /// Compression level
    pub compression_level: u8,
    /// Compress after age
    pub compress_after: Duration,
}

/// Compression algorithms
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum CompressionAlgorithm {
    Gzip,
    Zstd,
    Lz4,
    Brotli,
    Snappy,
}

/// Backup configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BackupConfig {
    /// Enable backups
    pub enabled: bool,
    /// Backup frequency
    pub backup_frequency: Duration,
    /// Backup retention period
    pub backup_retention: Duration,
    /// Backup destination
    pub backup_destination: BackupDestination,
}

/// Backup destinations
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum BackupDestination {
    /// Local file system
    LocalFileSystem { path: String },
    /// Remote object storage
    ObjectStorage { endpoint: String, bucket: String },
    /// Remote database
    RemoteDatabase { connection_string: String },
}

/// Quantum optimization recommender
#[derive(Debug)]
pub struct QuantumOptimizationRecommender {
    pub recommendation_engine: String,
    pub confidence_threshold: f64,
}

/// Quantum network dashboard
#[derive(Debug)]
pub struct QuantumNetworkDashboard {
    pub dashboard_id: Uuid,
    pub active_widgets: Vec<String>,
    pub refresh_rate: Duration,
}

#[derive(Debug)]
pub struct TimeSeriesDatabase {
    pub database_type: String,
    pub connection_string: String,
    pub retention_policy: Duration,
}

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

impl TimeSeriesDatabase {
    pub fn new() -> Self {
        Self {
            database_type: "influxdb".to_string(),
            connection_string: "localhost:8086".to_string(),
            retention_policy: Duration::from_secs(86400 * 30), // 30 days
        }
    }
}

/// Data retention manager
#[derive(Debug, Clone)]
pub struct DataRetentionManager {
    pub retention_policies: HashMap<String, Duration>,
    pub compression_enabled: bool,
}

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

impl DataRetentionManager {
    pub fn new() -> Self {
        Self {
            retention_policies: HashMap::new(),
            compression_enabled: true,
        }
    }
}

/// Data compression system
#[derive(Debug, Clone)]
pub struct DataCompressionSystem {
    pub compression_algorithm: String,
    pub compression_ratio: f64,
}

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

impl DataCompressionSystem {
    pub fn new() -> Self {
        Self {
            compression_algorithm: "gzip".to_string(),
            compression_ratio: 0.7,
        }
    }
}

/// Historical analytics engine
#[derive(Debug, Clone)]
pub struct HistoricalAnalyticsEngine {
    pub analysis_window: Duration,
    pub aggregation_levels: Vec<String>,
}

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

impl HistoricalAnalyticsEngine {
    pub fn new() -> Self {
        Self {
            analysis_window: Duration::from_secs(86400), // 24 hours
            aggregation_levels: vec!["minute".to_string(), "hour".to_string(), "day".to_string()],
        }
    }
}

/// Data export system
#[derive(Debug, Clone)]
pub struct DataExportSystem {
    pub supported_formats: Vec<String>,
    pub export_batch_size: usize,
}

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

impl DataExportSystem {
    pub fn new() -> Self {
        Self {
            supported_formats: vec!["csv".to_string(), "json".to_string(), "parquet".to_string()],
            export_batch_size: 10000,
        }
    }
}