quantrs2-device 0.1.3

//! Metrics collection, alerting, and resource allocation for distributed quantum computation

use super::super::types::*;
use async_trait::async_trait;
use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use std::collections::{HashMap, VecDeque};
use std::sync::Arc;
use std::time::Duration;
use uuid::Uuid;

/// Metrics collection system
#[derive(Debug)]
pub struct MetricsCollector {
    pub metrics_storage: Arc<dyn MetricsStorage + Send + Sync>,
    pub collection_interval: Duration,
    pub metrics_aggregator: Arc<MetricsAggregator>,
    pub alerting_system: Arc<AlertingSystem>,
}

/// Trait for metrics storage
#[async_trait]
pub trait MetricsStorage: std::fmt::Debug {
    async fn store_metric(&self, metric: &Metric) -> Result<()>;
    async fn query_metrics(&self, query: &MetricsQuery) -> Result<Vec<Metric>>;
    async fn aggregate_metrics(&self, aggregation: &AggregationQuery) -> Result<AggregatedMetrics>;
}

/// Individual metric data point
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Metric {
    pub metric_name: String,
    pub value: f64,
    pub timestamp: DateTime<Utc>,
    pub tags: HashMap<String, String>,
    pub node_id: Option<NodeId>,
}

/// Metrics query structure
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MetricsQuery {
    pub metric_names: Vec<String>,
    pub time_range: (DateTime<Utc>, DateTime<Utc>),
    pub filters: HashMap<String, String>,
    pub limit: Option<u32>,
}

/// Aggregation query
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AggregationQuery {
    pub metric_name: String,
    pub aggregation_function: AggregationFunction,
    pub time_range: (DateTime<Utc>, DateTime<Utc>),
    pub group_by: Vec<String>,
}

/// Aggregation functions
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum AggregationFunction {
    Sum,
    Average,
    Min,
    Max,
    Count,
    Percentile(f64),
    StandardDeviation,
}

/// Aggregated metrics result
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AggregatedMetrics {
    pub metric_name: String,
    pub aggregation_function: AggregationFunction,
    pub value: f64,
    pub time_range: (DateTime<Utc>, DateTime<Utc>),
    pub group_by_values: HashMap<String, f64>,
}

/// Metrics aggregation engine
#[derive(Debug)]
pub struct MetricsAggregator {
    pub aggregation_strategies: Vec<AggregationStrategy>,
    pub real_time_aggregation: bool,
    pub batch_size: u32,
}

/// Aggregation strategy
#[derive(Debug, Clone)]
pub struct AggregationStrategy {
    pub metric_pattern: String,
    pub aggregation_interval: Duration,
    pub functions: Vec<AggregationFunction>,
    pub retention_period: Duration,
}

/// Alerting system for monitoring
#[derive(Debug)]
pub struct AlertingSystem {
    pub alert_rules: Vec<AlertRule>,
    pub notification_channels: HashMap<String, Box<dyn NotificationChannel + Send + Sync>>,
    pub alert_history: Arc<std::sync::RwLock<VecDeque<AlertNotification>>>,
}

/// Alert rule definition
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AlertRule {
    pub rule_id: String,
    pub metric_name: String,
    pub condition: AlertCondition,
    pub threshold: f64,
    pub severity: super::fault_tolerance::Severity,
    pub notification_channels: Vec<String>,
    pub cooldown_period: Duration,
}

/// Alert conditions
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum AlertCondition {
    GreaterThan,
    LessThan,
    Equals,
    NotEquals,
    RateOfChange(f64),
    AnomalyDetection,
}

/// Alert notification
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AlertNotification {
    pub alert_id: Uuid,
    pub rule_id: String,
    pub timestamp: DateTime<Utc>,
    pub severity: super::fault_tolerance::Severity,
    pub message: String,
    pub affected_nodes: Vec<NodeId>,
    pub metric_value: f64,
}

/// Trait for notification channels
#[async_trait]
pub trait NotificationChannel: std::fmt::Debug {
    async fn send_notification(&self, alert: &AlertNotification) -> Result<()>;
    fn get_channel_type(&self) -> String;
    fn is_available(&self) -> bool;
}

/// Resource allocation system
#[derive(Debug)]
pub struct ResourceAllocator {
    pub allocation_strategies: HashMap<String, Box<dyn AllocationStrategy + Send + Sync>>,
    pub resource_monitor: Arc<ResourceMonitor>,
    pub allocation_history: Arc<std::sync::RwLock<VecDeque<AllocationRecord>>>,
}

/// Trait for resource allocation strategies
pub trait AllocationStrategy: std::fmt::Debug {
    fn allocate_resources(
        &self,
        request: &ExecutionRequest,
        available_resources: &HashMap<NodeId, AvailableResources>,
    ) -> Result<AllocationPlan>;

    fn deallocate_resources(&self, allocation: &AllocationPlan) -> Result<()>;

    fn estimate_allocation_time(&self, request: &ExecutionRequest) -> Duration;
}

/// Available resources on a node
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AvailableResources {
    pub available_qubits: u32,
    pub available_memory_mb: u32,
    pub available_cpu_percentage: f64,
    pub available_network_bandwidth_mbps: f64,
    pub estimated_availability_time: Duration,
}

/// Resource allocation plan
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AllocationPlan {
    pub plan_id: Uuid,
    pub allocations: HashMap<NodeId, super::fault_tolerance::ResourceAllocation>,
    pub estimated_cost: f64,
    pub estimated_execution_time: Duration,
    pub allocation_timestamp: DateTime<Utc>,
}

/// Resource allocation record
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AllocationRecord {
    pub record_id: Uuid,
    pub allocation_plan: AllocationPlan,
    pub actual_execution_time: Option<Duration>,
    pub actual_cost: Option<f64>,
    pub success: Option<bool>,
    pub performance_metrics: Option<PerformanceMetrics>,
}

/// Resource monitoring system
#[derive(Debug)]
pub struct ResourceMonitor {
    pub monitoring_agents: HashMap<NodeId, Box<dyn MonitoringAgent + Send + Sync>>,
    pub monitoring_interval: Duration,
    pub resource_predictions: Arc<ResourcePredictor>,
}

/// Trait for monitoring agents
#[async_trait]
pub trait MonitoringAgent: std::fmt::Debug {
    async fn collect_resource_metrics(&self) -> Result<ResourceMetrics>;
    async fn predict_resource_usage(&self, horizon: Duration) -> Result<ResourceUsagePrediction>;
    fn get_agent_health(&self) -> AgentHealth;
}

/// Resource metrics from monitoring
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ResourceMetrics {
    pub timestamp: DateTime<Utc>,
    pub cpu_utilization: f64,
    pub memory_utilization: f64,
    pub network_utilization: f64,
    pub qubit_utilization: f64,
    pub queue_length: u32,
    pub active_computations: u32,
}

/// Resource usage prediction
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ResourceUsagePrediction {
    pub prediction_horizon: Duration,
    pub predicted_cpu_usage: f64,
    pub predicted_memory_usage: f64,
    pub predicted_network_usage: f64,
    pub predicted_qubit_usage: f64,
    pub confidence_interval: (f64, f64),
}

/// Monitoring agent health status
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AgentHealth {
    pub is_healthy: bool,
    pub last_successful_collection: DateTime<Utc>,
    pub error_rate: f64,
    pub response_time: Duration,
}

/// Resource predictor for capacity planning
#[derive(Debug)]
pub struct ResourcePredictor {
    pub prediction_models: HashMap<String, Box<dyn PredictionModel + Send + Sync>>,
    pub training_scheduler: Arc<TrainingScheduler>,
    pub model_evaluator: Arc<ModelEvaluator>,
}

/// Trait for prediction models
#[async_trait]
pub trait PredictionModel: std::fmt::Debug {
    async fn predict(
        &self,
        features: &HashMap<String, f64>,
        horizon: Duration,
    ) -> Result<PredictionResult>;

    async fn train(&mut self, training_data: &[TrainingDataPoint]) -> Result<TrainingResult>;

    fn get_model_accuracy(&self) -> f64;
}

/// Prediction result
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PredictionResult {
    pub predicted_value: f64,
    pub confidence: f64,
    pub prediction_interval: (f64, f64),
    pub model_used: String,
}

/// Training result for ML models
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TrainingResult {
    pub training_success: bool,
    pub model_accuracy: f64,
    pub training_time: Duration,
    pub validation_metrics: HashMap<String, f64>,
}

/// Training scheduler for ML models
#[derive(Debug)]
pub struct TrainingScheduler {
    pub training_schedule: HashMap<String, TrainingConfig>,
    pub auto_retraining: bool,
    pub performance_threshold: f64,
}

/// Training configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TrainingConfig {
    pub model_name: String,
    pub training_frequency: Duration,
    pub training_data_size: u32,
    pub validation_split: f64,
    pub hyperparameters: HashMap<String, f64>,
}

/// Model evaluator for performance assessment
#[derive(Debug)]
pub struct ModelEvaluator {
    pub evaluation_metrics: Vec<String>,
    pub cross_validation_folds: u32,
    pub benchmark_datasets: HashMap<String, Vec<TrainingDataPoint>>,
}

/// In-memory metrics storage for testing
#[derive(Debug)]
pub struct InMemoryMetricsStorage {
    pub metrics: Arc<std::sync::RwLock<Vec<Metric>>>,
}

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

impl InMemoryMetricsStorage {
    pub fn new() -> Self {
        Self {
            metrics: Arc::new(std::sync::RwLock::new(vec![])),
        }
    }
}

#[async_trait]
impl MetricsStorage for InMemoryMetricsStorage {
    async fn store_metric(&self, metric: &Metric) -> Result<()> {
        let mut metrics = self.metrics.write().expect("Metrics RwLock poisoned");
        metrics.push(metric.clone());
        Ok(())
    }

    async fn query_metrics(&self, query: &MetricsQuery) -> Result<Vec<Metric>> {
        let metrics = self.metrics.read().expect("Metrics RwLock poisoned");
        let filtered: Vec<Metric> = metrics
            .iter()
            .filter(|m| {
                query.metric_names.contains(&m.metric_name)
                    && m.timestamp >= query.time_range.0
                    && m.timestamp <= query.time_range.1
            })
            .cloned()
            .collect();
        Ok(filtered)
    }

    async fn aggregate_metrics(&self, aggregation: &AggregationQuery) -> Result<AggregatedMetrics> {
        let metrics = self.metrics.read().expect("Metrics RwLock poisoned");
        let filtered: Vec<&Metric> = metrics
            .iter()
            .filter(|m| {
                m.metric_name == aggregation.metric_name
                    && m.timestamp >= aggregation.time_range.0
                    && m.timestamp <= aggregation.time_range.1
            })
            .collect();

        let value = match aggregation.aggregation_function {
            AggregationFunction::Average => {
                let sum: f64 = filtered.iter().map(|m| m.value).sum();
                if filtered.is_empty() {
                    0.0
                } else {
                    sum / filtered.len() as f64
                }
            }
            AggregationFunction::Sum => filtered.iter().map(|m| m.value).sum(),
            AggregationFunction::Max => filtered
                .iter()
                .map(|m| m.value)
                .fold(f64::NEG_INFINITY, f64::max),
            AggregationFunction::Min => filtered
                .iter()
                .map(|m| m.value)
                .fold(f64::INFINITY, f64::min),
            AggregationFunction::Count => filtered.len() as f64,
            _ => 0.0, // Simplified for other functions
        };

        Ok(AggregatedMetrics {
            metric_name: aggregation.metric_name.clone(),
            aggregation_function: aggregation.aggregation_function.clone(),
            value,
            time_range: aggregation.time_range,
            group_by_values: HashMap::new(),
        })
    }
}

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

impl MetricsCollector {
    pub fn new() -> Self {
        Self {
            metrics_storage: Arc::new(InMemoryMetricsStorage::new()),
            collection_interval: Duration::from_secs(1),
            metrics_aggregator: Arc::new(MetricsAggregator::new()),
            alerting_system: Arc::new(AlertingSystem::new()),
        }
    }
}

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

impl MetricsAggregator {
    pub const fn new() -> Self {
        Self {
            aggregation_strategies: vec![],
            real_time_aggregation: true,
            batch_size: 1000,
        }
    }
}

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

impl AlertingSystem {
    pub fn new() -> Self {
        Self {
            alert_rules: vec![],
            notification_channels: HashMap::new(),
            alert_history: Arc::new(std::sync::RwLock::new(VecDeque::new())),
        }
    }
}

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

impl ResourceAllocator {
    pub fn new() -> Self {
        Self {
            allocation_strategies: HashMap::new(),
            resource_monitor: Arc::new(ResourceMonitor::new()),
            allocation_history: Arc::new(std::sync::RwLock::new(VecDeque::new())),
        }
    }

    pub fn allocate_resources_for_partitions(
        &self,
        _partitions: &[CircuitPartition],
        nodes: &HashMap<NodeId, NodeInfo>,
    ) -> Result<AllocationPlan> {
        let mut allocations = HashMap::new();

        for node_id in nodes.keys() {
            allocations.insert(
                node_id.clone(),
                super::fault_tolerance::ResourceAllocation {
                    allocated_qubits: vec![],
                    memory_allocated_mb: 100,
                    cpu_allocated_percentage: 50.0,
                    network_bandwidth_allocated_mbps: 100.0,
                },
            );
        }

        Ok(AllocationPlan {
            plan_id: Uuid::new_v4(),
            allocations,
            estimated_cost: 100.0,
            estimated_execution_time: Duration::from_secs(10),
            allocation_timestamp: Utc::now(),
        })
    }
}

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

impl ResourceMonitor {
    pub fn new() -> Self {
        Self {
            monitoring_agents: HashMap::new(),
            monitoring_interval: Duration::from_secs(1),
            resource_predictions: Arc::new(ResourcePredictor::new()),
        }
    }
}

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

impl ResourcePredictor {
    pub fn new() -> Self {
        Self {
            prediction_models: HashMap::new(),
            training_scheduler: Arc::new(TrainingScheduler::new()),
            model_evaluator: Arc::new(ModelEvaluator::new()),
        }
    }
}

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

impl TrainingScheduler {
    pub fn new() -> Self {
        Self {
            training_schedule: HashMap::new(),
            auto_retraining: true,
            performance_threshold: 0.9,
        }
    }
}

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

impl ModelEvaluator {
    pub fn new() -> Self {
        Self {
            evaluation_metrics: vec![
                "accuracy".to_string(),
                "precision".to_string(),
                "recall".to_string(),
            ],
            cross_validation_folds: 5,
            benchmark_datasets: HashMap::new(),
        }
    }
}