torsh-distributed 0.1.2

//! Green Computing for Distributed Training
//!
//! This module provides comprehensive energy efficiency and sustainability features for
//! distributed deep learning, including:
//! - Energy consumption monitoring and optimization
//! - Carbon footprint tracking and reduction strategies
//! - Adaptive scheduling based on renewable energy availability
//! - Dynamic power management and GPU throttling
#![allow(clippy::await_holding_lock)]
//! - Green training algorithms and efficiency metrics
//! - Sustainable distributed training policies

// Framework infrastructure - components designed for future use
#![allow(dead_code)]
use crate::{TorshDistributedError, TorshResult};
use serde::{Deserialize, Serialize};
use std::collections::{HashMap, VecDeque};
use std::sync::{Arc, Mutex, RwLock};
use std::time::{Duration, SystemTime};
use tokio::time::interval;

/// Green computing configuration for sustainable distributed training
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GreenComputingConfig {
    /// Enable energy monitoring and optimization
    pub energy_monitoring: bool,
    /// Enable carbon footprint tracking
    pub carbon_tracking: bool,
    /// Target energy efficiency (operations per joule)
    pub target_efficiency: f64,
    /// Maximum carbon footprint per training run (kg CO2)
    pub max_carbon_footprint: f64,
    /// Enable renewable energy optimization
    pub renewable_energy_optimization: bool,
    /// Enable dynamic power management
    pub dynamic_power_management: bool,
    /// Power cap per device (watts)
    pub device_power_cap: f64,
    /// Energy budget per training epoch (watt-hours)
    pub energy_budget_per_epoch: f64,
    /// Enable green training algorithms
    pub green_algorithms: bool,
    /// Sustainability reporting configuration
    pub sustainability_reporting: SustainabilityReportingConfig,
}

impl Default for GreenComputingConfig {
    fn default() -> Self {
        Self {
            energy_monitoring: true,
            carbon_tracking: true,
            target_efficiency: 100.0,   // operations per joule
            max_carbon_footprint: 10.0, // kg CO2
            renewable_energy_optimization: true,
            dynamic_power_management: true,
            device_power_cap: 250.0,         // watts
            energy_budget_per_epoch: 1000.0, // watt-hours
            green_algorithms: true,
            sustainability_reporting: SustainabilityReportingConfig::default(),
        }
    }
}

/// Sustainability reporting configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SustainabilityReportingConfig {
    /// Enable periodic sustainability reports
    pub enable_reports: bool,
    /// Reporting interval in seconds
    pub report_interval: u64,
    /// Include energy efficiency metrics
    pub include_efficiency_metrics: bool,
    /// Include carbon footprint analysis
    pub include_carbon_analysis: bool,
    /// Include renewable energy utilization
    pub include_renewable_utilization: bool,
    /// Export reports to file
    pub export_to_file: bool,
    /// Report file path
    pub report_file_path: String,
}

impl Default for SustainabilityReportingConfig {
    fn default() -> Self {
        Self {
            enable_reports: true,
            report_interval: 300, // 5 minutes
            include_efficiency_metrics: true,
            include_carbon_analysis: true,
            include_renewable_utilization: true,
            export_to_file: true,
            report_file_path: "sustainability_report.json".to_string(),
        }
    }
}

/// Energy consumption data for a device
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DeviceEnergyData {
    /// Device identifier
    pub device_id: String,
    /// Current power consumption (watts)
    pub current_power: f64,
    /// Peak power consumption (watts)
    pub peak_power: f64,
    /// Average power consumption (watts)
    pub average_power: f64,
    /// Total energy consumed (watt-hours)
    pub total_energy: f64,
    /// Energy efficiency (operations per joule)
    pub efficiency: f64,
    /// Power utilization percentage
    pub power_utilization: f64,
    /// Temperature (celsius)
    pub temperature: f64,
    /// Timestamp of last update
    pub last_updated: SystemTime,
}

impl DeviceEnergyData {
    pub fn new(device_id: String) -> Self {
        Self {
            device_id,
            current_power: 0.0,
            peak_power: 0.0,
            average_power: 0.0,
            total_energy: 0.0,
            efficiency: 0.0,
            power_utilization: 0.0,
            temperature: 25.0,
            last_updated: SystemTime::now(),
        }
    }

    /// Update energy consumption data
    pub fn update_power(&mut self, power: f64, operations: f64) {
        self.current_power = power;
        self.peak_power = self.peak_power.max(power);

        // Update average power using exponential moving average
        self.average_power = 0.9 * self.average_power + 0.1 * power;

        // Calculate energy consumption (assuming 1-second intervals)
        self.total_energy += power / 3600.0; // Convert to watt-hours

        // Calculate efficiency (operations per joule)
        if power > 0.0 {
            self.efficiency = operations / power;
        }

        self.last_updated = SystemTime::now();
    }
}

/// Carbon footprint data
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CarbonFootprintData {
    /// Total CO2 emissions (kg)
    pub total_co2_kg: f64,
    /// CO2 emissions per epoch (kg)
    pub co2_per_epoch: f64,
    /// CO2 emissions per operation (g)
    pub co2_per_operation: f64,
    /// Carbon intensity of current grid (g CO2/kWh)
    pub grid_carbon_intensity: f64,
    /// Renewable energy percentage
    pub renewable_energy_percentage: f64,
    /// Offset credits applied (kg CO2)
    pub offset_credits: f64,
    /// Net carbon footprint (kg CO2)
    pub net_carbon_footprint: f64,
}

impl Default for CarbonFootprintData {
    fn default() -> Self {
        Self {
            total_co2_kg: 0.0,
            co2_per_epoch: 0.0,
            co2_per_operation: 0.0,
            grid_carbon_intensity: 400.0, // Global average g CO2/kWh
            renewable_energy_percentage: 0.0,
            offset_credits: 0.0,
            net_carbon_footprint: 0.0,
        }
    }
}

/// Renewable energy data source
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RenewableEnergyData {
    /// Current renewable energy availability (percentage)
    pub availability_percentage: f64,
    /// Renewable energy forecast (next 24 hours)
    pub forecast: Vec<f64>,
    /// Current grid carbon intensity (g CO2/kWh)
    pub current_carbon_intensity: f64,
    /// Predicted carbon intensity (next 24 hours)
    pub carbon_intensity_forecast: Vec<f64>,
    /// Last updated timestamp
    pub last_updated: SystemTime,
}

impl Default for RenewableEnergyData {
    fn default() -> Self {
        Self {
            availability_percentage: 30.0, // Default 30% renewable
            forecast: vec![25.0, 30.0, 35.0, 40.0, 45.0, 50.0], // Sample forecast
            current_carbon_intensity: 400.0,
            carbon_intensity_forecast: vec![380.0, 360.0, 340.0, 320.0, 300.0, 280.0],
            last_updated: SystemTime::now(),
        }
    }
}

/// Green training optimization strategies
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum GreenOptimizationStrategy {
    /// Minimize total energy consumption
    MinimizeEnergy,
    /// Minimize carbon footprint
    MinimizeCarbon,
    /// Maximize use of renewable energy
    MaximizeRenewable,
    /// Balance performance and sustainability
    Balanced,
    /// Custom optimization with user-defined weights
    Custom,
}

/// Power management strategy for devices
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum PowerManagementStrategy {
    /// Dynamic voltage and frequency scaling
    DVFS,
    /// GPU power limiting
    PowerCapping,
    /// Idle state management
    IdleManagement,
    /// Load balancing for power efficiency
    LoadBalancing,
    /// Thermal throttling
    ThermalThrottling,
}

/// Green computing manager for sustainable distributed training
pub struct GreenComputingManager {
    config: GreenComputingConfig,
    device_energy_data: Arc<RwLock<HashMap<String, DeviceEnergyData>>>,
    carbon_footprint: Arc<Mutex<CarbonFootprintData>>,
    renewable_energy: Arc<RwLock<RenewableEnergyData>>,
    optimization_strategy: GreenOptimizationStrategy,
    power_management_enabled: Arc<std::sync::atomic::AtomicBool>,
    sustainability_metrics: Arc<Mutex<SustainabilityMetrics>>,
    training_scheduler: Option<GreenTrainingScheduler>,
}

impl GreenComputingManager {
    /// Create a new green computing manager
    pub fn new(config: GreenComputingConfig) -> TorshResult<Self> {
        Ok(Self {
            config: config.clone(),
            device_energy_data: Arc::new(RwLock::new(HashMap::new())),
            carbon_footprint: Arc::new(Mutex::new(CarbonFootprintData::default())),
            renewable_energy: Arc::new(RwLock::new(RenewableEnergyData::default())),
            optimization_strategy: GreenOptimizationStrategy::Balanced,
            power_management_enabled: Arc::new(std::sync::atomic::AtomicBool::new(
                config.dynamic_power_management,
            )),
            sustainability_metrics: Arc::new(Mutex::new(SustainabilityMetrics::new())),
            training_scheduler: Some(GreenTrainingScheduler::new(config)?),
        })
    }

    /// Initialize green computing for a device
    pub fn initialize_device(&self, device_id: String) -> TorshResult<()> {
        let mut devices = self.device_energy_data.write().map_err(|_| {
            TorshDistributedError::InternalError("Failed to acquire device data lock".to_string())
        })?;

        devices.insert(device_id.clone(), DeviceEnergyData::new(device_id.clone()));

        tracing::info!("Initialized green computing for device: {}", device_id);
        Ok(())
    }

    /// Update energy consumption for a device
    pub fn update_device_energy(
        &self,
        device_id: &str,
        power_watts: f64,
        operations: f64,
    ) -> TorshResult<()> {
        let mut devices = self.device_energy_data.write().map_err(|_| {
            TorshDistributedError::InternalError("Failed to acquire device data lock".to_string())
        })?;

        if let Some(device_data) = devices.get_mut(device_id) {
            device_data.update_power(power_watts, operations);

            // Check power cap compliance
            if power_watts > self.config.device_power_cap {
                tracing::warn!(
                    "Device {} exceeds power cap: {:.2}W > {:.2}W",
                    device_id,
                    power_watts,
                    self.config.device_power_cap
                );

                // Trigger power management if enabled
                if self
                    .power_management_enabled
                    .load(std::sync::atomic::Ordering::Relaxed)
                {
                    self.apply_power_management(device_id, power_watts)?;
                }
            }

            // Update carbon footprint
            self.update_carbon_footprint(power_watts / 3600.0)?; // Convert to kWh
        }

        Ok(())
    }

    /// Update carbon footprint calculation
    fn update_carbon_footprint(&self, energy_kwh: f64) -> TorshResult<()> {
        let mut carbon = self.carbon_footprint.lock().map_err(|_| {
            TorshDistributedError::InternalError("Failed to acquire carbon data lock".to_string())
        })?;

        let renewable_data = self.renewable_energy.read().map_err(|_| {
            TorshDistributedError::InternalError(
                "Failed to acquire renewable data lock".to_string(),
            )
        })?;

        // Calculate CO2 emissions based on grid carbon intensity and renewable energy
        let effective_carbon_intensity = renewable_data.current_carbon_intensity
            * (1.0 - renewable_data.availability_percentage / 100.0);

        let co2_emissions_kg = energy_kwh * effective_carbon_intensity / 1000.0; // Convert g to kg

        carbon.total_co2_kg += co2_emissions_kg;
        carbon.grid_carbon_intensity = renewable_data.current_carbon_intensity;
        carbon.renewable_energy_percentage = renewable_data.availability_percentage;
        carbon.net_carbon_footprint = carbon.total_co2_kg - carbon.offset_credits;

        // Check carbon footprint limit
        if carbon.net_carbon_footprint > self.config.max_carbon_footprint {
            tracing::warn!(
                "Carbon footprint limit exceeded: {:.3} kg > {:.3} kg",
                carbon.net_carbon_footprint,
                self.config.max_carbon_footprint
            );
        }

        Ok(())
    }

    /// Apply power management strategies
    fn apply_power_management(&self, device_id: &str, current_power: f64) -> TorshResult<()> {
        let target_power = self.config.device_power_cap * 0.9; // Target 90% of cap
        let power_reduction_ratio = target_power / current_power;

        tracing::info!(
            "Applying power management for device {}: reducing power by {:.1}%",
            device_id,
            (1.0 - power_reduction_ratio) * 100.0
        );

        // In a real implementation, this would:
        // 1. Reduce GPU frequency/voltage
        // 2. Limit CUDA core usage
        // 3. Adjust memory bandwidth
        // 4. Enable thermal throttling

        Ok(())
    }

    /// Get current sustainability metrics
    pub fn get_sustainability_metrics(&self) -> TorshResult<SustainabilityMetrics> {
        let metrics = self.sustainability_metrics.lock().map_err(|_| {
            TorshDistributedError::InternalError("Failed to acquire metrics lock".to_string())
        })?;

        Ok(metrics.clone())
    }

    /// Optimize training schedule based on renewable energy availability
    pub fn optimize_training_schedule(&self) -> TorshResult<TrainingScheduleRecommendation> {
        let renewable_data = self.renewable_energy.read().map_err(|_| {
            TorshDistributedError::InternalError(
                "Failed to acquire renewable data lock".to_string(),
            )
        })?;

        // Find optimal training windows based on renewable energy forecast
        let mut optimal_windows = Vec::new();
        for (hour, &renewable_percentage) in renewable_data.forecast.iter().enumerate() {
            if renewable_percentage > 40.0 {
                // Above 40% renewable
                optimal_windows.push(TrainingWindow {
                    start_hour: hour,
                    duration_hours: 1,
                    renewable_percentage,
                    carbon_intensity: renewable_data
                        .carbon_intensity_forecast
                        .get(hour)
                        .copied()
                        .unwrap_or(400.0),
                    priority: if renewable_percentage > 60.0 {
                        Priority::High
                    } else {
                        Priority::Medium
                    },
                });
            }
        }

        Ok(TrainingScheduleRecommendation {
            current_renewable_percentage: renewable_data.availability_percentage,
            recommended_action: if renewable_data.availability_percentage > 50.0 {
                ScheduleAction::TrainNow
            } else if renewable_data.availability_percentage < 20.0 {
                ScheduleAction::Defer
            } else {
                ScheduleAction::ReduceIntensity
            },
            optimal_windows,
            estimated_carbon_savings: self.calculate_carbon_savings(&renewable_data)?,
        })
    }

    /// Calculate potential carbon savings from green optimization
    fn calculate_carbon_savings(&self, renewable_data: &RenewableEnergyData) -> TorshResult<f64> {
        let baseline_intensity = 500.0; // Baseline carbon intensity (g CO2/kWh)
        let current_intensity = renewable_data.current_carbon_intensity
            * (1.0 - renewable_data.availability_percentage / 100.0);

        let savings_percentage = (baseline_intensity - current_intensity) / baseline_intensity;
        Ok(savings_percentage.max(0.0))
    }

    /// Generate sustainability report
    pub async fn generate_sustainability_report(&self) -> TorshResult<SustainabilityReport> {
        let devices = self.device_energy_data.read().map_err(|_| {
            TorshDistributedError::InternalError("Failed to acquire device data lock".to_string())
        })?;

        let carbon = self.carbon_footprint.lock().map_err(|_| {
            TorshDistributedError::InternalError("Failed to acquire carbon data lock".to_string())
        })?;

        let renewable = self.renewable_energy.read().map_err(|_| {
            TorshDistributedError::InternalError(
                "Failed to acquire renewable data lock".to_string(),
            )
        })?;

        let total_energy: f64 = devices.values().map(|d| d.total_energy).sum();
        let average_efficiency: f64 =
            devices.values().map(|d| d.efficiency).sum::<f64>() / devices.len() as f64;
        let peak_power: f64 = devices.values().map(|d| d.peak_power).sum();

        let report = SustainabilityReport {
            timestamp: SystemTime::now(),
            total_energy_kwh: total_energy,
            total_carbon_kg: carbon.total_co2_kg,
            renewable_energy_percentage: renewable.availability_percentage,
            average_efficiency,
            peak_power_kw: peak_power / 1000.0,
            device_count: devices.len(),
            carbon_intensity: renewable.current_carbon_intensity,
            net_carbon_footprint: carbon.net_carbon_footprint,
            sustainability_score: self
                .calculate_sustainability_score(&devices, &carbon, &renewable)?,
        };

        // Export to file if configured
        if self.config.sustainability_reporting.export_to_file {
            self.export_report_to_file(&report).await?;
        }

        Ok(report)
    }

    /// Calculate overall sustainability score (0-100)
    fn calculate_sustainability_score(
        &self,
        devices: &HashMap<String, DeviceEnergyData>,
        carbon: &CarbonFootprintData,
        renewable: &RenewableEnergyData,
    ) -> TorshResult<f64> {
        let energy_efficiency_score = devices
            .values()
            .map(|d| d.efficiency.min(1000.0) / 1000.0 * 100.0)
            .sum::<f64>()
            / devices.len() as f64;

        let renewable_score = renewable.availability_percentage;

        let carbon_score = ((self.config.max_carbon_footprint - carbon.net_carbon_footprint)
            / self.config.max_carbon_footprint
            * 100.0)
            .max(0.0);

        // Weighted average: 40% efficiency, 30% renewable, 30% carbon
        let overall_score =
            0.4 * energy_efficiency_score + 0.3 * renewable_score + 0.3 * carbon_score;

        Ok(overall_score.clamp(0.0, 100.0))
    }

    /// Export sustainability report to file
    async fn export_report_to_file(&self, report: &SustainabilityReport) -> TorshResult<()> {
        let json_data = serde_json::to_string_pretty(report)
            .map_err(|e| TorshDistributedError::SerializationError(e.to_string()))?;

        tokio::fs::write(
            &self.config.sustainability_reporting.report_file_path,
            json_data,
        )
        .await
        .map_err(|e| TorshDistributedError::IoError(e.to_string()))?;

        tracing::info!(
            "Sustainability report exported to: {}",
            self.config.sustainability_reporting.report_file_path
        );

        Ok(())
    }

    /// Start automatic sustainability monitoring
    pub async fn start_monitoring(&self) -> TorshResult<()> {
        if !self.config.sustainability_reporting.enable_reports {
            return Ok(());
        }

        let report_interval =
            Duration::from_secs(self.config.sustainability_reporting.report_interval);
        let mut interval_timer = interval(report_interval);

        loop {
            interval_timer.tick().await;

            match self.generate_sustainability_report().await {
                Ok(report) => {
                    tracing::info!(
                        "Sustainability report generated - Score: {:.1}/100, Carbon: {:.3} kg CO2",
                        report.sustainability_score,
                        report.net_carbon_footprint
                    );
                }
                Err(e) => {
                    tracing::error!("Failed to generate sustainability report: {}", e);
                }
            }
        }
    }
}

/// Sustainability metrics tracker
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SustainabilityMetrics {
    /// Energy efficiency trend (operations per joule over time)
    pub efficiency_trend: VecDeque<(SystemTime, f64)>,
    /// Carbon intensity trend (g CO2/kWh over time)
    pub carbon_intensity_trend: VecDeque<(SystemTime, f64)>,
    /// Renewable energy utilization trend (percentage over time)
    pub renewable_utilization_trend: VecDeque<(SystemTime, f64)>,
    /// Power consumption trend (watts over time)
    pub power_consumption_trend: VecDeque<(SystemTime, f64)>,
}

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

impl SustainabilityMetrics {
    pub fn new() -> Self {
        Self {
            efficiency_trend: VecDeque::with_capacity(1000),
            carbon_intensity_trend: VecDeque::with_capacity(1000),
            renewable_utilization_trend: VecDeque::with_capacity(1000),
            power_consumption_trend: VecDeque::with_capacity(1000),
        }
    }

    /// Add data point to trends
    pub fn add_data_point(
        &mut self,
        efficiency: f64,
        carbon_intensity: f64,
        renewable_percentage: f64,
        power_consumption: f64,
    ) {
        let timestamp = SystemTime::now();

        self.efficiency_trend.push_back((timestamp, efficiency));
        self.carbon_intensity_trend
            .push_back((timestamp, carbon_intensity));
        self.renewable_utilization_trend
            .push_back((timestamp, renewable_percentage));
        self.power_consumption_trend
            .push_back((timestamp, power_consumption));

        // Keep only last 1000 data points
        if self.efficiency_trend.len() > 1000 {
            self.efficiency_trend.pop_front();
            self.carbon_intensity_trend.pop_front();
            self.renewable_utilization_trend.pop_front();
            self.power_consumption_trend.pop_front();
        }
    }
}

/// Green training scheduler for optimizing training based on sustainability
pub struct GreenTrainingScheduler {
    config: GreenComputingConfig,
    schedule_recommendations: Arc<RwLock<Vec<TrainingScheduleRecommendation>>>,
}

impl GreenTrainingScheduler {
    pub fn new(config: GreenComputingConfig) -> TorshResult<Self> {
        Ok(Self {
            config,
            schedule_recommendations: Arc::new(RwLock::new(Vec::new())),
        })
    }

    /// Get current training recommendation
    pub fn get_current_recommendation(
        &self,
    ) -> TorshResult<Option<TrainingScheduleRecommendation>> {
        let recommendations = self.schedule_recommendations.read().map_err(|_| {
            TorshDistributedError::InternalError(
                "Failed to acquire recommendations lock".to_string(),
            )
        })?;

        Ok(recommendations.last().cloned())
    }
}

/// Training schedule recommendation based on green computing optimization
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TrainingScheduleRecommendation {
    /// Current renewable energy percentage
    pub current_renewable_percentage: f64,
    /// Recommended action
    pub recommended_action: ScheduleAction,
    /// Optimal training windows
    pub optimal_windows: Vec<TrainingWindow>,
    /// Estimated carbon savings percentage
    pub estimated_carbon_savings: f64,
}

/// Recommended scheduling action
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum ScheduleAction {
    /// Start training immediately
    TrainNow,
    /// Defer training to optimal window
    Defer,
    /// Reduce training intensity
    ReduceIntensity,
    /// Pause training temporarily
    Pause,
}

/// Optimal training window
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TrainingWindow {
    /// Start hour (0-23)
    pub start_hour: usize,
    /// Duration in hours
    pub duration_hours: usize,
    /// Renewable energy percentage during window
    pub renewable_percentage: f64,
    /// Carbon intensity (g CO2/kWh)
    pub carbon_intensity: f64,
    /// Window priority
    pub priority: Priority,
}

/// Priority level for training windows
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum Priority {
    High,
    Medium,
    Low,
}

/// Comprehensive sustainability report
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SustainabilityReport {
    /// Report timestamp
    pub timestamp: SystemTime,
    /// Total energy consumption (kWh)
    pub total_energy_kwh: f64,
    /// Total carbon emissions (kg CO2)
    pub total_carbon_kg: f64,
    /// Renewable energy percentage
    pub renewable_energy_percentage: f64,
    /// Average energy efficiency (operations per joule)
    pub average_efficiency: f64,
    /// Peak power consumption (kW)
    pub peak_power_kw: f64,
    /// Number of devices monitored
    pub device_count: usize,
    /// Current grid carbon intensity (g CO2/kWh)
    pub carbon_intensity: f64,
    /// Net carbon footprint after offsets (kg CO2)
    pub net_carbon_footprint: f64,
    /// Overall sustainability score (0-100)
    pub sustainability_score: f64,
}

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

    #[test]
    fn test_green_computing_config_default() {
        let config = GreenComputingConfig::default();
        assert!(config.energy_monitoring);
        assert!(config.carbon_tracking);
        assert_eq!(config.target_efficiency, 100.0);
        assert_eq!(config.max_carbon_footprint, 10.0);
    }

    #[test]
    fn test_device_energy_data_update() {
        let mut device = DeviceEnergyData::new("gpu-0".to_string());
        device.update_power(200.0, 1000.0);

        assert_eq!(device.current_power, 200.0);
        assert_eq!(device.peak_power, 200.0);
        assert_eq!(device.efficiency, 5.0); // 1000 ops / 200 watts
    }

    #[tokio::test]
    async fn test_green_computing_manager_creation() {
        let config = GreenComputingConfig::default();
        let manager = GreenComputingManager::new(config).unwrap();

        // Test device initialization
        manager.initialize_device("gpu-0".to_string()).unwrap();

        // Test energy update
        manager.update_device_energy("gpu-0", 150.0, 500.0).unwrap();
    }

    #[tokio::test]
    async fn test_sustainability_report_generation() {
        let config = GreenComputingConfig::default();
        let manager = GreenComputingManager::new(config).unwrap();

        manager.initialize_device("gpu-0".to_string()).unwrap();
        manager.update_device_energy("gpu-0", 150.0, 500.0).unwrap();

        let report = manager.generate_sustainability_report().await.unwrap();
        assert!(report.sustainability_score >= 0.0 && report.sustainability_score <= 100.0);
    }

    #[test]
    fn test_training_schedule_optimization() {
        let config = GreenComputingConfig::default();
        let manager = GreenComputingManager::new(config).unwrap();

        let recommendation = manager.optimize_training_schedule().unwrap();
        assert!(recommendation.current_renewable_percentage >= 0.0);
        assert!(recommendation.estimated_carbon_savings >= 0.0);
    }

    #[test]
    fn test_carbon_footprint_calculation() {
        let mut carbon = CarbonFootprintData {
            grid_carbon_intensity: 400.0, // g CO2/kWh
            ..Default::default()
        };

        // Simulate 1 kWh consumption
        let co2_emissions = 1.0 * carbon.grid_carbon_intensity / 1000.0; // Convert to kg
        carbon.total_co2_kg += co2_emissions;

        assert_eq!(carbon.total_co2_kg, 0.4); // 400g = 0.4kg CO2
    }

    #[test]
    fn test_sustainability_metrics() {
        let mut metrics = SustainabilityMetrics::new();
        metrics.add_data_point(100.0, 350.0, 45.0, 200.0);

        assert_eq!(metrics.efficiency_trend.len(), 1);
        assert_eq!(metrics.carbon_intensity_trend.len(), 1);
        assert_eq!(metrics.renewable_utilization_trend.len(), 1);
        assert_eq!(metrics.power_consumption_trend.len(), 1);
    }
}