scirs2-metrics 0.3.2

//! Performance monitoring for neuromorphic systems
//!
//! This module provides comprehensive performance tracking and analysis
//! for neuromorphic computing systems.

#![allow(clippy::too_many_arguments)]
#![allow(dead_code)]

use scirs2_core::numeric::Float;
use std::collections::{HashMap, VecDeque};
use std::time::{Duration, Instant};

/// Neuromorphic performance monitor
#[derive(Debug)]
pub struct NeuromorphicPerformanceMonitor<F: Float> {
    /// Performance metrics
    pub metrics: PerformanceMetrics<F>,
    /// Monitoring configuration
    pub config: MonitoringConfig,
    /// Performance history
    pub history: VecDeque<PerformanceSnapshot<F>>,
    /// Alert thresholds
    pub alert_thresholds: HashMap<String, F>,
}

/// Performance metrics collection
#[derive(Debug, Clone)]
pub struct PerformanceMetrics<F: Float> {
    /// Processing speed (spikes/second)
    pub processing_speed: F,
    /// Energy efficiency
    pub energy_efficiency: F,
    /// Memory usage
    pub memory_usage: F,
    /// Accuracy metrics
    pub accuracy: F,
    /// Latency measurements
    pub latency: Duration,
    /// Throughput
    pub throughput: F,
    /// Network utilization
    pub network_utilization: F,
    /// Adaptation rate
    pub adaptation_rate: F,
}

/// Monitoring configuration
#[derive(Debug, Clone)]
pub struct MonitoringConfig {
    /// Monitoring interval
    pub interval: Duration,
    /// History retention
    pub retention_period: Duration,
    /// Enable real-time monitoring
    pub real_time_monitoring: bool,
    /// Performance targets
    pub targets: HashMap<String, f64>,
}

/// Performance snapshot
#[derive(Debug, Clone)]
pub struct PerformanceSnapshot<F: Float> {
    pub timestamp: Instant,
    pub metrics: PerformanceMetrics<F>,
    pub system_state: SystemState,
    pub resource_usage: ResourceUsage<F>,
}

/// System state information
#[derive(Debug, Clone)]
pub struct SystemState {
    pub active_neurons: usize,
    pub active_synapses: usize,
    pub network_activity: f64,
    pub learning_active: bool,
    pub adaptation_mode: String,
}

/// Resource usage tracking
#[derive(Debug, Clone)]
pub struct ResourceUsage<F: Float> {
    pub cpu_usage: F,
    pub memory_usage: F,
    pub power_consumption: F,
    pub bandwidth_usage: F,
}

impl<F: Float + std::iter::Sum> NeuromorphicPerformanceMonitor<F> {
    /// Create new performance monitor
    pub fn new() -> Self {
        let mut alert_thresholds = HashMap::new();
        alert_thresholds.insert(
            "accuracy".to_string(),
            F::from(0.8).expect("Failed to convert constant to float"),
        );
        alert_thresholds.insert(
            "energy_efficiency".to_string(),
            F::from(0.7).expect("Failed to convert constant to float"),
        );
        alert_thresholds.insert(
            "processing_speed".to_string(),
            F::from(100.0).expect("Failed to convert constant to float"),
        );

        Self {
            metrics: PerformanceMetrics::new(),
            config: MonitoringConfig::default(),
            history: VecDeque::new(),
            alert_thresholds,
        }
    }

    /// Update performance metrics
    pub fn update(
        &mut self,
        network_state: &super::spiking_networks::NetworkState<F>,
    ) -> crate::error::Result<()> {
        // Update current metrics
        self.metrics.update_from_network_state(network_state)?;

        // Take snapshot if interval elapsed
        if self.should_take_snapshot() {
            self.take_snapshot()?;
        }

        // Check for alerts
        self.check_alerts()?;

        Ok(())
    }

    /// Check if should take snapshot
    fn should_take_snapshot(&self) -> bool {
        self.history.is_empty()
            || self
                .history
                .back()
                .expect("Operation failed")
                .timestamp
                .elapsed()
                >= self.config.interval
    }

    /// Take performance snapshot
    fn take_snapshot(&mut self) -> crate::error::Result<()> {
        let snapshot = PerformanceSnapshot {
            timestamp: Instant::now(),
            metrics: self.metrics.clone(),
            system_state: SystemState::default(),
            resource_usage: ResourceUsage::default(),
        };

        self.history.push_back(snapshot);

        // Maintain bounded history
        while let Some(front) = self.history.front() {
            if front.timestamp.elapsed() > self.config.retention_period {
                self.history.pop_front();
            } else {
                break;
            }
        }

        Ok(())
    }

    /// Check for performance alerts
    fn check_alerts(&self) -> crate::error::Result<()> {
        for (metric_name, threshold) in &self.alert_thresholds {
            let current_value = match metric_name.as_str() {
                "accuracy" => self.metrics.accuracy,
                "energy_efficiency" => self.metrics.energy_efficiency,
                "processing_speed" => self.metrics.processing_speed,
                _ => continue,
            };

            if current_value < *threshold {
                // In a real implementation, this would trigger alerts
                println!(
                    "Alert: {} below threshold: {} < {}",
                    metric_name,
                    current_value.to_f64().unwrap_or(0.0),
                    threshold.to_f64().unwrap_or(0.0)
                );
            }
        }
        Ok(())
    }

    /// Get performance statistics
    pub fn get_statistics(&self) -> PerformanceStatistics<F> {
        if self.history.is_empty() {
            return PerformanceStatistics::empty();
        }

        let mut accuracy_values = Vec::new();
        let mut efficiency_values = Vec::new();
        let mut speed_values = Vec::new();

        for snapshot in &self.history {
            accuracy_values.push(snapshot.metrics.accuracy);
            efficiency_values.push(snapshot.metrics.energy_efficiency);
            speed_values.push(snapshot.metrics.processing_speed);
        }

        PerformanceStatistics {
            average_accuracy: self.calculate_average(&accuracy_values),
            average_efficiency: self.calculate_average(&efficiency_values),
            average_speed: self.calculate_average(&speed_values),
            min_accuracy: accuracy_values.iter().cloned().fold(F::infinity(), F::min),
            max_accuracy: accuracy_values
                .iter()
                .cloned()
                .fold(F::neg_infinity(), F::max),
            total_snapshots: self.history.len(),
            monitoring_duration: if let (Some(first), Some(last)) =
                (self.history.front(), self.history.back())
            {
                last.timestamp.duration_since(first.timestamp)
            } else {
                Duration::from_secs(0)
            },
        }
    }

    /// Calculate average of values
    fn calculate_average(&self, values: &[F]) -> F {
        if values.is_empty() {
            F::zero()
        } else {
            values.iter().cloned().sum::<F>() / F::from(values.len()).expect("Operation failed")
        }
    }
}

impl<F: Float + std::iter::Sum> PerformanceMetrics<F> {
    /// Create new performance metrics
    pub fn new() -> Self {
        Self {
            processing_speed: F::zero(),
            energy_efficiency: F::zero(),
            memory_usage: F::zero(),
            accuracy: F::zero(),
            latency: Duration::from_millis(0),
            throughput: F::zero(),
            network_utilization: F::zero(),
            adaptation_rate: F::zero(),
        }
    }

    /// Update metrics from network state
    pub fn update_from_network_state(
        &mut self,
        network_state: &super::spiking_networks::NetworkState<F>,
    ) -> crate::error::Result<()> {
        // Calculate processing speed based on activity levels
        let total_activity = network_state.activity_levels.iter().cloned().sum::<F>();
        self.processing_speed = total_activity;

        // Estimate energy efficiency (simplified)
        self.energy_efficiency = if self.processing_speed > F::zero() {
            self.accuracy / self.processing_speed
        } else {
            F::zero()
        };

        // Update network utilization
        let active_neurons = network_state
            .activity_levels
            .iter()
            .filter(|&&x| x > F::from(0.1).expect("Failed to convert constant to float"))
            .count();
        self.network_utilization = F::from(active_neurons).expect("Failed to convert to float")
            / F::from(network_state.activity_levels.len()).expect("Operation failed");

        Ok(())
    }
}

impl Default for MonitoringConfig {
    fn default() -> Self {
        Self {
            interval: Duration::from_secs(1),
            retention_period: Duration::from_secs(3600), // 1 hour
            real_time_monitoring: true,
            targets: HashMap::new(),
        }
    }
}

impl Default for SystemState {
    fn default() -> Self {
        Self {
            active_neurons: 0,
            active_synapses: 0,
            network_activity: 0.0,
            learning_active: true,
            adaptation_mode: "standard".to_string(),
        }
    }
}

impl<F: Float> Default for ResourceUsage<F> {
    fn default() -> Self {
        Self {
            cpu_usage: F::zero(),
            memory_usage: F::zero(),
            power_consumption: F::zero(),
            bandwidth_usage: F::zero(),
        }
    }
}

/// Performance statistics
#[derive(Debug, Clone)]
pub struct PerformanceStatistics<F: Float> {
    pub average_accuracy: F,
    pub average_efficiency: F,
    pub average_speed: F,
    pub min_accuracy: F,
    pub max_accuracy: F,
    pub total_snapshots: usize,
    pub monitoring_duration: Duration,
}

impl<F: Float> PerformanceStatistics<F> {
    pub fn empty() -> Self {
        Self {
            average_accuracy: F::zero(),
            average_efficiency: F::zero(),
            average_speed: F::zero(),
            min_accuracy: F::zero(),
            max_accuracy: F::zero(),
            total_snapshots: 0,
            monitoring_duration: Duration::from_secs(0),
        }
    }
}