trustformers-debug 0.1.1

//! Environmental Impact Monitoring Module
//!
//! This module provides comprehensive monitoring of environmental impact during model
//! training and inference, including carbon footprint tracking, energy consumption
//! analysis, and sustainability recommendations.

pub mod carbon_tracking;
pub mod config;
pub mod efficiency_analysis;
pub mod energy_monitoring;
pub mod reporting;
pub mod sustainability;
pub mod types;

pub use carbon_tracking::CarbonFootprintTracker;
pub use config::EnvironmentalConfig;
pub use efficiency_analysis::EfficiencyAnalyzer;
pub use reporting::EnvironmentalReportingEngine;
pub use sustainability::SustainabilityAdvisor;
pub use types::*;

use anyhow::Result;
use std::time::{Duration, Instant};
use tracing::{info, warn};

/// Environmental impact monitor for tracking carbon footprint and energy usage
#[derive(Debug)]
pub struct EnvironmentalMonitor {
    config: EnvironmentalConfig,
    carbon_tracker: CarbonFootprintTracker,
    energy_monitor: energy_monitoring::EnergyConsumptionMonitor,
    efficiency_analyzer: EfficiencyAnalyzer,
    sustainability_advisor: SustainabilityAdvisor,
    reporting_engine: EnvironmentalReportingEngine,
}

impl EnvironmentalMonitor {
    /// Create a new environmental monitor
    pub fn new(config: EnvironmentalConfig) -> Self {
        Self {
            config: config.clone(),
            carbon_tracker: CarbonFootprintTracker::new(&config),
            energy_monitor: energy_monitoring::EnergyConsumptionMonitor::new(),
            efficiency_analyzer: EfficiencyAnalyzer::new(),
            sustainability_advisor: SustainabilityAdvisor::new(),
            reporting_engine: EnvironmentalReportingEngine::new(),
        }
    }

    /// Start environmental monitoring
    pub async fn start_monitoring(&mut self) -> Result<()> {
        info!(
            "Starting environmental impact monitoring for region: {}",
            self.config.region
        );

        // Device monitors are already initialized via the constructor

        // Start monitoring loops
        self.start_monitoring_loops().await?;

        // Initialize sustainability goals
        self.sustainability_advisor.initialize_sustainability_goals().await?;

        Ok(())
    }

    /// Record energy consumption and carbon emissions for a training/inference session
    pub async fn record_session(
        &mut self,
        session_info: SessionInfo,
    ) -> Result<SessionImpactReport> {
        info!(
            "Recording environmental impact for {:?} session",
            session_info.session_type
        );

        let _start_time = Instant::now();

        // Predict energy consumption based on session duration
        let predicted_energy_kwh = self
            .energy_monitor
            .predict_energy_consumption(session_info.duration_hours as u32);

        // Use predicted energy if available, otherwise use estimated from session info
        let energy_kwh = if predicted_energy_kwh > 0.0 {
            predicted_energy_kwh
        } else {
            session_info.estimated_energy_kwh
        };

        // Create energy measurement from prediction or estimate
        let energy_measurement = EnergyMeasurement {
            timestamp: std::time::SystemTime::now(),
            device_id: "session".to_string(),
            power_watts: energy_kwh * 1000.0 / session_info.duration_hours, // Convert back to watts
            energy_kwh,
            utilization: 0.8, // Assume 80% utilization
            temperature: None,
            efficiency_ratio: 1.0,
        };

        // Calculate carbon footprint
        let carbon_measurement = self.carbon_tracker.record_emissions(
            energy_measurement.energy_kwh,
            &session_info.region,
            session_info.session_type.clone(),
        )?;

        // Update cumulative metrics
        self.update_cumulative_metrics(&energy_measurement, &carbon_measurement).await?;

        // Analyze efficiency
        let efficiency_analysis = self
            .efficiency_analyzer
            .analyze_session_efficiency(&session_info, &energy_measurement)
            .await?;

        // Generate impact report
        let cost_analysis = self.calculate_cost_impact(&energy_measurement).await?;
        let recommendations = self.generate_session_recommendations(&efficiency_analysis).await?;

        let impact_report = SessionImpactReport {
            session_info,
            carbon_emissions: CarbonEmissions {
                total_co2_kg: carbon_measurement.co2_emissions_kg,
                scope1_emissions_kg: 0.0, // Direct emissions
                scope2_emissions_kg: carbon_measurement.scope2_emissions_kg,
                scope3_emissions_kg: carbon_measurement.scope3_emissions_kg.unwrap_or(0.0),
                training_emissions_kg: carbon_measurement.co2_emissions_kg,
                inference_emissions_kg: 0.0,
                equivalent_metrics: EquivalentMetrics {
                    car_miles_equivalent: carbon_measurement.co2_emissions_kg * 2.31, // kg CO2 to miles
                    tree_months_to_offset: carbon_measurement.co2_emissions_kg * 0.039, // kg CO2 to tree-months
                    coal_pounds_equivalent: carbon_measurement.co2_emissions_kg * 2.2, // kg CO2 to coal pounds
                    households_daily_energy: carbon_measurement.co2_emissions_kg * 0.123, // kg CO2 to household days
                },
            },
            energy_consumption: energy_measurement.energy_kwh,
            cost_usd: cost_analysis.total_cost_usd,
            efficiency_metrics: EnergyEfficiencyMetrics {
                operations_per_kwh: 1.0 / energy_measurement.energy_kwh, // Inverse of energy per operation
                flops_per_watt: 1000.0 / energy_measurement.power_watts, // Approximate FLOPS per watt
                model_energy_efficiency: efficiency_analysis.efficiency_score,
                training_energy_efficiency: efficiency_analysis.efficiency_score,
                inference_energy_efficiency: efficiency_analysis.efficiency_score,
                comparative_efficiency: ComparativeEfficiency {
                    vs_cpu_only: efficiency_analysis.efficiency_score * 1.5, // Assume 1.5x better than CPU
                    vs_previous_generation: efficiency_analysis.efficiency_score * 1.2, // Assume 1.2x better than previous gen
                    vs_cloud_baseline: efficiency_analysis.efficiency_score,
                    efficiency_percentile: efficiency_analysis.efficiency_score * 100.0, // Convert to percentile
                },
            },
            recommendations,
            energy_measurement,
            carbon_measurement,
            efficiency_analysis,
            cost_analysis,
        };

        // Check for alerts
        self.check_environmental_alerts(&impact_report).await?;

        Ok(impact_report)
    }

    /// Get real-time environmental metrics
    pub async fn get_real_time_metrics(&self) -> Result<RealTimeEnvironmentalMetrics> {
        let current_power = self.energy_monitor.get_current_consumption();
        let carbon_intensity = self.carbon_tracker.get_carbon_intensity(&self.config.region);
        let _energy_price = self.config.energy_price_per_kwh;

        Ok(RealTimeEnvironmentalMetrics {
            timestamp: std::time::SystemTime::now(),
            current_power_watts: current_power,
            energy_consumed_kwh: current_power / 1000.0, // Convert to kWh for 1 hour
            co2_emissions_kg: (current_power / 1000.0) * carbon_intensity / 1000.0,
            efficiency_ratio: self.calculate_real_time_efficiency().await?,
            temperature_celsius: Some(75.0), // Mock temperature
        })
    }

    /// Optimize scheduling for minimum environmental impact
    pub async fn optimize_scheduling(
        &self,
        workload: WorkloadDescription,
    ) -> Result<OptimalSchedule> {
        info!("Optimizing schedule for minimum environmental impact");

        // Get carbon intensity forecasts
        let carbon_forecasts = self.get_carbon_intensity_forecasts().await?;

        // Get energy price forecasts
        let price_forecasts = self.get_energy_price_forecasts().await?;

        // Calculate optimal timing
        let optimal_time = self
            .find_optimal_execution_time(&workload, &carbon_forecasts, &price_forecasts)
            .await?;

        // Estimate savings
        let savings = self.calculate_projected_savings(&workload, &optimal_time).await?;

        Ok(OptimalSchedule {
            schedule_type: ScheduleType::LowCarbon,
            start_time: optimal_time,
            duration_hours: workload.estimated_duration_hours,
            projected_savings: savings,
            carbon_intensity_forecast: carbon_forecasts
                .iter()
                .map(|f| f.predicted_carbon_intensity)
                .collect(),
            confidence: 0.85,
        })
    }

    /// Generate comprehensive environmental impact report
    pub async fn generate_environmental_report(
        &self,
        report_type: ReportType,
    ) -> Result<EnvironmentalReport> {
        self.reporting_engine.generate_environmental_report(report_type).await
    }

    /// Get sustainability recommendations
    pub async fn get_sustainability_recommendations(
        &self,
    ) -> Result<Vec<SustainabilityRecommendation>> {
        self.sustainability_advisor.get_sustainability_recommendations().await
    }

    /// Get efficiency opportunities
    pub async fn get_efficiency_opportunities(&self) -> Result<Vec<EfficiencyOpportunity>> {
        self.efficiency_analyzer.analyze_efficiency_opportunities().await
    }

    /// Get carbon emissions data
    pub fn get_cumulative_emissions(&self) -> &CarbonEmissions {
        self.carbon_tracker.get_cumulative_emissions()
    }

    /// Get measurement history
    pub fn get_measurement_history(&self) -> &[CarbonMeasurement] {
        self.carbon_tracker.get_measurement_history()
    }

    // Private implementation methods

    async fn start_monitoring_loops(&self) -> Result<()> {
        let interval = Duration::from_secs(self.config.monitoring_interval_secs);

        // In a full implementation, these would be actual background tasks
        // For now, we'll just log that monitoring has started
        info!(
            "Environmental monitoring loops started with interval: {:?}",
            interval
        );

        Ok(())
    }

    async fn update_cumulative_metrics(
        &mut self,
        _energy: &EnergyMeasurement,
        _carbon: &CarbonMeasurement,
    ) -> Result<()> {
        // Cumulative metrics are updated within the carbon tracker
        Ok(())
    }

    async fn calculate_real_time_efficiency(&self) -> Result<f64> {
        // Simplified efficiency calculation
        Ok(0.87) // 87% efficiency
    }

    async fn calculate_cost_impact(&self, energy: &EnergyMeasurement) -> Result<CostAnalysis> {
        let energy_cost = energy.energy_kwh * self.config.energy_price_per_kwh;
        let carbon_cost = self.calculate_carbon_cost(energy.energy_kwh).await?;

        Ok(CostAnalysis {
            energy_cost_usd: energy_cost,
            carbon_cost_usd: Some(carbon_cost),
            infrastructure_cost_usd: energy_cost * 0.1, // 10% infrastructure overhead
            total_cost_usd: energy_cost + carbon_cost,
            cost_per_operation: (energy_cost + carbon_cost) / 1000.0, // Assuming 1000 operations
        })
    }

    async fn calculate_carbon_cost(&self, energy_kwh: f64) -> Result<f64> {
        // Simplified carbon pricing (varies by region and policy)
        let carbon_price_per_ton = 50.0; // USD per ton CO2
        let carbon_intensity = self.carbon_tracker.get_carbon_intensity(&self.config.region);
        let co2_tons = (energy_kwh * carbon_intensity / 1000.0) / 1000.0;

        Ok(co2_tons * carbon_price_per_ton)
    }

    async fn generate_session_recommendations(
        &self,
        efficiency: &SessionEfficiencyAnalysis,
    ) -> Result<Vec<String>> {
        let mut recommendations = Vec::new();

        if efficiency.efficiency_score < 0.7 {
            recommendations
                .push("Consider optimizing batch size for better GPU utilization".to_string());
        }

        if efficiency.waste_percentage > 30.0 {
            recommendations
                .push("Implement gradient accumulation to reduce memory overhead".to_string());
        }

        recommendations.push("Schedule training during low carbon intensity periods".to_string());
        recommendations
            .push("Consider mixed precision training to reduce energy consumption".to_string());

        Ok(recommendations)
    }

    async fn check_environmental_alerts(&self, report: &SessionImpactReport) -> Result<()> {
        if report.carbon_measurement.co2_emissions_kg > self.config.carbon_alert_threshold {
            warn!(
                "Carbon emission alert: {:.2} kg CO2 exceeds threshold of {:.2} kg",
                report.carbon_measurement.co2_emissions_kg, self.config.carbon_alert_threshold
            );
        }

        if report.energy_measurement.energy_kwh > self.config.energy_alert_threshold {
            warn!(
                "Energy consumption alert: {:.2} kWh exceeds threshold of {:.2} kWh",
                report.energy_measurement.energy_kwh, self.config.energy_alert_threshold
            );
        }

        Ok(())
    }

    async fn get_carbon_intensity_forecasts(&self) -> Result<Vec<CarbonForecast>> {
        // Mock carbon intensity forecasts - in reality would fetch from API
        let mut forecasts = Vec::new();
        let current_time = std::time::SystemTime::now();

        for hour in 0..24 {
            forecasts.push(CarbonForecast {
                timestamp: current_time + Duration::from_secs(hour * 3600),
                predicted_carbon_intensity: 350.0 + (hour as f64 * 10.0).sin() * 100.0,
                renewable_percentage: 40.0 + (hour as f64 * 8.0).cos() * 20.0,
                confidence: 0.8,
            });
        }

        Ok(forecasts)
    }

    async fn get_energy_price_forecasts(&self) -> Result<Vec<EnergyPriceForecast>> {
        // Mock energy price forecasts
        let mut forecasts = Vec::new();
        let current_time = std::time::SystemTime::now();

        for hour in 0..24 {
            forecasts.push(EnergyPriceForecast {
                timestamp: current_time + Duration::from_secs(hour * 3600),
                predicted_price_per_kwh: self.config.energy_price_per_kwh
                    * (1.0 + (hour as f64 * 6.0).sin() * 0.3),
                confidence: 0.85,
            });
        }

        Ok(forecasts)
    }

    async fn find_optimal_execution_time(
        &self,
        workload: &WorkloadDescription,
        carbon_forecasts: &[CarbonForecast],
        price_forecasts: &[EnergyPriceForecast],
    ) -> Result<std::time::SystemTime> {
        let mut best_time = std::time::SystemTime::now();
        let mut best_score = f64::INFINITY;

        for (carbon_forecast, price_forecast) in carbon_forecasts.iter().zip(price_forecasts.iter())
        {
            // Calculate combined score (lower is better)
            let carbon_score =
                carbon_forecast.predicted_carbon_intensity * workload.estimated_energy_kwh;
            let cost_score =
                price_forecast.predicted_price_per_kwh * workload.estimated_energy_kwh * 100.0;
            let combined_score = carbon_score + cost_score;

            if combined_score < best_score {
                best_score = combined_score;
                best_time = carbon_forecast.timestamp;
            }
        }

        Ok(best_time)
    }

    async fn calculate_projected_savings(
        &self,
        workload: &WorkloadDescription,
        _optimal_time: &std::time::SystemTime,
    ) -> Result<ProjectedSavings> {
        Ok(ProjectedSavings {
            energy_savings_kwh: 0.0, // Scheduling doesn't reduce energy, just shifts timing
            cost_savings_usd: workload.estimated_energy_kwh
                * self.config.energy_price_per_kwh
                * 0.2, // 20% cost savings
            carbon_reduction_kg: workload.estimated_energy_kwh * 0.15, // 15% carbon reduction
            efficiency_improvement_percent: 0.0, // Scheduling doesn't improve efficiency
        })
    }
}

// Supporting data structures
#[derive(Debug, Clone)]
#[allow(dead_code)]
struct CarbonForecast {
    timestamp: std::time::SystemTime,
    predicted_carbon_intensity: f64,
    #[allow(dead_code)]
    renewable_percentage: f64,
    confidence: f64,
}

#[derive(Debug, Clone)]
#[allow(dead_code)]
struct EnergyPriceForecast {
    #[allow(dead_code)]
    timestamp: std::time::SystemTime,
    predicted_price_per_kwh: f64,
    confidence: f64,
}

/// Convenience functions

/// Create environmental monitor with default configuration
pub fn create_environmental_monitor() -> EnvironmentalMonitor {
    EnvironmentalMonitor::new(EnvironmentalConfig::default())
}

/// Create environmental monitor for specific region
pub fn create_regional_environmental_monitor(region: String) -> EnvironmentalMonitor {
    let mut config = EnvironmentalConfig::default();
    config.region = region;
    EnvironmentalMonitor::new(config)
}

/// Macro for quick environmental impact recording
#[macro_export]
macro_rules! record_environmental_impact {
    ($monitor:expr, $session_type:expr, $duration:expr, $energy:expr) => {{
        let session_info = SessionInfo {
            session_id: uuid::Uuid::new_v4().to_string(),
            session_type: $session_type,
            duration_hours: $duration,
            workload_description: "default".to_string(),
            region: "US-West".to_string(),
            estimated_energy_kwh: $energy,
        };
        $monitor.record_session(session_info).await
    }};
}

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

    #[tokio::test]
    async fn test_environmental_monitor_creation() {
        let monitor = EnvironmentalMonitor::new(EnvironmentalConfig::default());
        assert_eq!(monitor.config.region, "US-West");
        assert!(monitor.config.enable_carbon_tracking);
    }

    #[tokio::test]
    async fn test_session_recording() {
        let mut monitor = EnvironmentalMonitor::new(EnvironmentalConfig::default());

        let session_info = SessionInfo {
            session_id: "test-session".to_string(),
            start_time: std::time::SystemTime::now(),
            session_type: MeasurementType::Training,
            duration_hours: 1.0,
            workload_description: "test training".to_string(),
            region: "US-West".to_string(),
            estimated_energy_kwh: 2.5,
        };

        let result = monitor.record_session(session_info).await;
        assert!(result.is_ok());

        let report = result.expect("operation failed in test");
        assert!(report.carbon_measurement.co2_emissions_kg > 0.0);
        assert!(report.energy_measurement.energy_kwh > 0.0);
    }

    #[tokio::test]
    async fn test_real_time_metrics() {
        let mut monitor = EnvironmentalMonitor::new(EnvironmentalConfig::default());

        // Add a device to get non-zero metrics
        use crate::environmental_monitor::types::{DeviceType, PowerMeasurementMethod};
        monitor
            .energy_monitor
            .add_device(
                "gpu-0".to_string(),
                DeviceType::GPU,
                PowerMeasurementMethod::Estimated,
            )
            .expect("operation failed in test");

        // Record a measurement to have some power consumption
        let _ = monitor.energy_monitor.record_measurement("gpu-0", 250.0, 0.8, Some(70.0));

        let metrics = monitor.get_real_time_metrics().await.expect("async operation failed");
        assert!(metrics.current_power_watts >= 0.0); // Changed to >= to allow 0.0 on fresh monitor
        assert!(metrics.efficiency_ratio > 0.0);
    }

    #[tokio::test]
    async fn test_scheduling_optimization() {
        let monitor = EnvironmentalMonitor::new(EnvironmentalConfig::default());

        let workload = WorkloadDescription {
            workload_name: "test workload".to_string(),
            workload_type: "training".to_string(),
            priority: WorkloadPriority::Medium,
            estimated_duration_hours: 2.0,
            resource_requirements: std::collections::HashMap::new(),
            estimated_energy_kwh: 5.0,
        };

        let schedule = monitor.optimize_scheduling(workload).await.expect("async operation failed");
        assert!(schedule.projected_savings.carbon_reduction_kg >= 0.0);
    }

    #[tokio::test]
    async fn test_environmental_report_generation() {
        let monitor = EnvironmentalMonitor::new(EnvironmentalConfig::default());

        let report = monitor
            .generate_environmental_report(ReportType::Summary)
            .await
            .expect("async operation failed");
        assert!(!report.report_id.is_empty());
        assert!(!report.recommendations.is_empty());
    }

    #[test]
    fn test_convenience_functions() {
        let monitor = create_environmental_monitor();
        assert_eq!(monitor.config.region, "US-West");

        let regional_monitor = create_regional_environmental_monitor("EU-North".to_string());
        assert_eq!(regional_monitor.config.region, "EU-North");
    }
}