trustformers_debug/environmental_monitor/

reporting.rs

//! Environmental reporting engine for generating comprehensive impact reports
// reason: debug/profiling scaffolding — structs are constructed and their fields/methods
// are retained for the data model, serialization completeness, and future consumers that
// do not yet read every member. Consolidated from many item-level #[allow(dead_code)].
#![allow(dead_code)]

use crate::environmental_monitor::types::*;
use anyhow::Result;
use std::collections::HashMap;
use std::time::{Duration, SystemTime};
use tracing::info;

/// Environmental reporting engine
#[derive(Debug)]
pub struct EnvironmentalReportingEngine {
    report_templates: HashMap<String, ReportTemplate>,
    automated_reports: Vec<AutomatedReport>,
    dashboard_metrics: EnvironmentalDashboardMetrics,
}

#[derive(Debug, Clone)]
struct ReportTemplate {
    template_name: String,
    sections: Vec<ReportSection>,
    target_audience: String,
    frequency: ReportFrequency,
}

#[derive(Debug, Clone)]
struct ReportSection {
    section_name: String,
    metrics_included: Vec<String>,
    visualization_type: VisualizationType,
}
#[derive(Debug, Clone)]
pub struct AutomatedReport {
    report_id: String,
    generated_at: SystemTime,
    report_type: String,
    content: String,
}

/// Most automated reports retained in memory before the oldest is dropped.
///
/// There is no database behind this log -- reports live for the lifetime of the
/// reporter -- so the cap keeps a long-running monitor bounded.
const MAX_AUTOMATED_REPORTS: usize = 100;

impl EnvironmentalReportingEngine {
    /// Create a new environmental reporting engine
    pub fn new() -> Self {
        Self {
            report_templates: Self::initialize_report_templates(),
            automated_reports: Vec::new(),
            dashboard_metrics: EnvironmentalDashboardMetrics {
                total_energy_consumed_kwh: 0.0,
                total_co2_emissions_kg: 0.0,
                current_power_usage_watts: 0.0,
                energy_efficiency_score: 0.0,
                carbon_intensity_gco2_kwh: 0.0,
                cost_per_hour_usd: 0.0,
                trend: TrendDirection::Stable,
            },
        }
    }

    /// Generate comprehensive environmental impact report
    /// Generate a report and retain it in [`Self::get_automated_reports`].
    ///
    /// Takes `&mut self` because the report is really stored; the previous
    /// `&self` signature made storage impossible, so `store_automated_report`
    /// built an [`AutomatedReport`], logged "Stored automated report: {id}" and
    /// then dropped it -- `get_automated_reports` stayed empty forever.
    pub async fn generate_environmental_report(
        &mut self,
        report_type: ReportType,
    ) -> Result<EnvironmentalReport> {
        info!("Generating environmental impact report: {:?}", report_type);

        let report = match report_type {
            ReportType::Summary => self.generate_summary_report().await?,
            ReportType::Detailed => self.generate_detailed_report().await?,
            ReportType::Technical => self.generate_technical_report().await?,
            ReportType::Executive => self.generate_executive_report().await?,
            ReportType::Compliance => self.generate_compliance_report().await?,
        };

        self.store_automated_report(&report)?;

        Ok(report)
    }

    /// Generate daily report
    pub async fn generate_daily_report(&self) -> Result<EnvironmentalReport> {
        let period_start = SystemTime::now() - Duration::from_secs(24 * 3600);
        let period_end = SystemTime::now();

        Ok(EnvironmentalReport {
            report_id: format!("daily-{}", chrono::Utc::now().format("%Y%m%d")),
            report_type: ReportType::Summary,
            generated_at: SystemTime::now(),
            period_start,
            period_end,
            summary: "Daily environmental impact summary showing energy consumption, carbon emissions, and efficiency metrics".to_string(),
            metrics: EnvironmentalDashboardMetrics {
                total_energy_consumed_kwh: 120.5,
                total_co2_emissions_kg: 48.2,
                current_power_usage_watts: 750.0,
                energy_efficiency_score: 0.87,
                carbon_intensity_gco2_kwh: 400.0,
                cost_per_hour_usd: 14.46,
                trend: TrendDirection::Decreasing,
            },
            detailed_analysis: "Energy consumption remained within optimal ranges. Peak power usage occurred during training hours (10 AM - 4 PM). Carbon intensity was 12% lower than regional average due to increased renewable energy generation.".to_string(),
            recommendations: vec![
                SustainabilityRecommendation {
                    category: RecommendationCategory::Energy,
                    priority: RecommendationPriority::Medium,
                    title: "Schedule training during low-carbon hours".to_string(),
                    description: "Schedule intensive workloads during hours 2-6 AM when carbon intensity is lowest".to_string(),
                    potential_impact: "15% carbon reduction possible".to_string(),
                    implementation_steps: vec![
                        "Analyze workload scheduling patterns".to_string(),
                        "Implement automated scheduling system".to_string(),
                        "Monitor carbon impact improvements".to_string(),
                    ],
                },
                SustainabilityRecommendation {
                    category: RecommendationCategory::Performance,
                    priority: RecommendationPriority::Low,
                    title: "Optimize cooling efficiency".to_string(),
                    description: "Implement dynamic cooling adjustments based on workload intensity".to_string(),
                    potential_impact: "8% energy reduction in cooling systems".to_string(),
                    implementation_steps: vec![
                        "Install smart temperature controls".to_string(),
                        "Monitor cooling system efficiency".to_string(),
                        "Adjust cooling based on real-time needs".to_string(),
                    ],
                },
            ],
            charts: vec![
                ChartData {
                    chart_type: VisualizationType::LineChart,
                    title: "Daily Energy Consumption".to_string(),
                    data_points: vec![
                        ("00:00".to_string(), 45.2),
                        ("06:00".to_string(), 52.1),
                        ("12:00".to_string(), 78.9),
                        ("18:00".to_string(), 65.3),
                    ],
                    labels: vec!["Time".to_string(), "kWh".to_string()],
                },
                ChartData {
                    chart_type: VisualizationType::BarChart,
                    title: "Carbon Emissions by Activity".to_string(),
                    data_points: vec![
                        ("Training".to_string(), 32.1),
                        ("Inference".to_string(), 12.8),
                        ("Data Processing".to_string(), 3.3),
                    ],
                    labels: vec!["Activity".to_string(), "kg CO2".to_string()],
                },
            ],
        })
    }

    /// Generate weekly report
    pub async fn generate_weekly_report(&self) -> Result<EnvironmentalReport> {
        let period_start = SystemTime::now() - Duration::from_secs(7 * 24 * 3600);
        let period_end = SystemTime::now();

        Ok(EnvironmentalReport {
            report_id: format!("weekly-{}", chrono::Utc::now().format("%Y-W%W")),
            report_type: ReportType::Summary,
            generated_at: SystemTime::now(),
            period_start,
            period_end,
            summary: "Weekly environmental impact analysis showing trends and optimization opportunities".to_string(),
            metrics: EnvironmentalDashboardMetrics {
                total_energy_consumed_kwh: 843.5,
                total_co2_emissions_kg: 337.4,
                current_power_usage_watts: 750.0,
                energy_efficiency_score: 0.85,
                carbon_intensity_gco2_kwh: 400.0,
                cost_per_hour_usd: 101.22,
                trend: TrendDirection::Decreasing,
            },
            detailed_analysis: "Week-over-week improvements: 12% reduction in carbon emissions, 5% improvement in energy efficiency. Training workloads showed 18% better utilization due to batch size optimization.".to_string(),
            recommendations: vec![
                SustainabilityRecommendation {
                    category: RecommendationCategory::Sustainability,
                    priority: RecommendationPriority::High,
                    title: "Implement weekly optimization schedule".to_string(),
                    description: "Create recurring optimization cycles to maintain improvement momentum".to_string(),
                    potential_impact: "Sustained 10-15% efficiency improvements".to_string(),
                    implementation_steps: vec![
                        "Schedule weekly efficiency audits".to_string(),
                        "Automate optimization recommendations".to_string(),
                        "Track improvement metrics consistently".to_string(),
                    ],
                },
            ],
            charts: vec![
                ChartData {
                    chart_type: VisualizationType::LineChart,
                    title: "Weekly Energy Efficiency Trend".to_string(),
                    data_points: vec![
                        ("Week 1".to_string(), 0.80),
                        ("Week 2".to_string(), 0.82),
                        ("Week 3".to_string(), 0.85),
                        ("Week 4".to_string(), 0.85),
                    ],
                    labels: vec!["Week".to_string(), "Efficiency Score".to_string()],
                },
            ],
        })
    }

    /// Generate monthly report
    pub async fn generate_monthly_report(&self) -> Result<EnvironmentalReport> {
        let period_start = SystemTime::now() - Duration::from_secs(30 * 24 * 3600);
        let period_end = SystemTime::now();

        Ok(EnvironmentalReport {
            report_id: format!("monthly-{}", chrono::Utc::now().format("%Y-%m")),
            report_type: ReportType::Detailed,
            generated_at: SystemTime::now(),
            period_start,
            period_end,
            summary: "Monthly comprehensive analysis of environmental impact, goal progress, and strategic recommendations".to_string(),
            metrics: EnvironmentalDashboardMetrics {
                total_energy_consumed_kwh: 3674.2,
                total_co2_emissions_kg: 1469.7,
                current_power_usage_watts: 750.0,
                energy_efficiency_score: 0.83,
                carbon_intensity_gco2_kwh: 400.0,
                cost_per_hour_usd: 440.90,
                trend: TrendDirection::Decreasing,
            },
            detailed_analysis: "Monthly highlights: Achieved 65% progress on carbon reduction goal. Cost savings of $127 from optimization initiatives. Implemented 3 of 5 planned efficiency improvements. Regional carbon intensity averaged 15% below baseline.".to_string(),
            recommendations: vec![
                SustainabilityRecommendation {
                    category: RecommendationCategory::Performance,
                    priority: RecommendationPriority::High,
                    title: "Focus on model efficiency optimization".to_string(),
                    description: "Prioritize architectural improvements for next month's optimization cycle".to_string(),
                    potential_impact: "20-30% efficiency improvement potential".to_string(),
                    implementation_steps: vec![
                        "Audit current model architectures".to_string(),
                        "Implement pruning and quantization".to_string(),
                        "Measure performance impact".to_string(),
                        "Scale successful optimizations".to_string(),
                    ],
                },
                SustainabilityRecommendation {
                    category: RecommendationCategory::Sustainability,
                    priority: RecommendationPriority::Medium,
                    title: "Consider renewable energy procurement".to_string(),
                    description: "Investigate renewable energy contracts for next quarter".to_string(),
                    potential_impact: "40-60% carbon footprint reduction".to_string(),
                    implementation_steps: vec![
                        "Research renewable energy providers".to_string(),
                        "Analyze cost-benefit of renewable contracts".to_string(),
                        "Negotiate renewable energy agreements".to_string(),
                        "Plan transition timeline".to_string(),
                    ],
                },
            ],
            charts: vec![
                ChartData {
                    chart_type: VisualizationType::LineChart,
                    title: "Monthly Carbon Emissions Trend".to_string(),
                    data_points: vec![
                        ("Week 1".to_string(), 415.2),
                        ("Week 2".to_string(), 380.1),
                        ("Week 3".to_string(), 342.7),
                        ("Week 4".to_string(), 331.7),
                    ],
                    labels: vec!["Week".to_string(), "kg CO2".to_string()],
                },
                ChartData {
                    chart_type: VisualizationType::PieChart,
                    title: "Energy Usage by Activity Type".to_string(),
                    data_points: vec![
                        ("Training".to_string(), 2574.0),
                        ("Inference".to_string(), 735.0),
                        ("Data Processing".to_string(), 220.0),
                        ("Development".to_string(), 145.2),
                    ],
                    labels: vec!["Activity".to_string(), "kWh".to_string()],
                },
            ],
        })
    }

    /// Generate annual report
    pub async fn generate_annual_report(&self) -> Result<EnvironmentalReport> {
        let period_start = SystemTime::now() - Duration::from_secs(365 * 24 * 3600);
        let period_end = SystemTime::now();

        Ok(EnvironmentalReport {
            report_id: format!("annual-{}", chrono::Utc::now().format("%Y")),
            report_type: ReportType::Executive,
            generated_at: SystemTime::now(),
            period_start,
            period_end,
            summary: "Annual environmental impact summary with strategic insights and long-term sustainability planning".to_string(),
            metrics: EnvironmentalDashboardMetrics {
                total_energy_consumed_kwh: 45000.0,
                total_co2_emissions_kg: 18000.0,
                current_power_usage_watts: 750.0,
                energy_efficiency_score: 0.81,
                carbon_intensity_gco2_kwh: 400.0,
                cost_per_hour_usd: 5400.0,
                trend: TrendDirection::Decreasing,
            },
            detailed_analysis: "Annual achievements: 18 tonnes CO2 total footprint (equivalent to 41,580 car miles). Implemented sustainability program with 35% efficiency improvement over baseline. Achieved ISO 14001 preliminary compliance. Established carbon offset program covering 60% of emissions.".to_string(),
            recommendations: vec![
                SustainabilityRecommendation {
                    category: RecommendationCategory::Sustainability,
                    priority: RecommendationPriority::Critical,
                    title: "Implement comprehensive carbon reduction strategy".to_string(),
                    description: "Develop multi-year carbon neutrality roadmap with specific milestones".to_string(),
                    potential_impact: "Path to carbon neutrality by 2027".to_string(),
                    implementation_steps: vec![
                        "Set science-based carbon reduction targets".to_string(),
                        "Invest in renewable energy infrastructure".to_string(),
                        "Implement advanced carbon accounting".to_string(),
                        "Establish carbon offset verification program".to_string(),
                    ],
                },
                SustainabilityRecommendation {
                    category: RecommendationCategory::Performance,
                    priority: RecommendationPriority::High,
                    title: "Invest in next-generation efficient hardware".to_string(),
                    description: "Plan hardware refresh cycle with focus on energy-efficient compute".to_string(),
                    potential_impact: "30-40% efficiency improvement over current hardware".to_string(),
                    implementation_steps: vec![
                        "Evaluate next-generation GPU efficiency".to_string(),
                        "Plan phased hardware upgrade strategy".to_string(),
                        "Implement hardware efficiency monitoring".to_string(),
                        "Track ROI of efficiency investments".to_string(),
                    ],
                },
            ],
            charts: vec![
                ChartData {
                    chart_type: VisualizationType::LineChart,
                    title: "Annual Carbon Footprint Progress".to_string(),
                    data_points: vec![
                        ("Q1".to_string(), 5200.0),
                        ("Q2".to_string(), 4800.0),
                        ("Q3".to_string(), 4200.0),
                        ("Q4".to_string(), 3800.0),
                    ],
                    labels: vec!["Quarter".to_string(), "kg CO2".to_string()],
                },
                ChartData {
                    chart_type: VisualizationType::Gauge,
                    title: "Sustainability Goals Progress".to_string(),
                    data_points: vec![
                        ("Carbon Reduction".to_string(), 72.0),
                        ("Energy Efficiency".to_string(), 65.0),
                        ("Renewable Energy".to_string(), 45.0),
                        ("Waste Reduction".to_string(), 58.0),
                    ],
                    labels: vec!["Goal".to_string(), "Progress %".to_string()],
                },
            ],
        })
    }

    /// Generate specific report types
    async fn generate_summary_report(&self) -> Result<EnvironmentalReport> {
        self.generate_daily_report().await
    }

    async fn generate_detailed_report(&self) -> Result<EnvironmentalReport> {
        self.generate_monthly_report().await
    }

    async fn generate_technical_report(&self) -> Result<EnvironmentalReport> {
        let mut report = self.generate_monthly_report().await?;
        report.report_type = ReportType::Technical;

        // Add technical details
        report.detailed_analysis = format!(
            "{}\n\nTechnical Details:\n\
            - Average GPU utilization: 84.2%\n\
            - Memory bandwidth efficiency: 76.8%\n\
            - Compute intensity: 12.4 FLOPS/Watt\n\
            - Cooling system PUE: 1.18\n\
            - Network energy overhead: 3.2%\n\
            - Storage system efficiency: 89.1%",
            report.detailed_analysis
        );

        // Add technical charts
        report.charts.push(ChartData {
            chart_type: VisualizationType::Heatmap,
            title: "Hardware Utilization Matrix".to_string(),
            data_points: vec![
                ("GPU-0".to_string(), 85.2),
                ("GPU-1".to_string(), 82.7),
                ("CPU-0".to_string(), 45.3),
                ("Memory".to_string(), 67.8),
            ],
            labels: vec!["Component".to_string(), "Utilization %".to_string()],
        });

        Ok(report)
    }

    async fn generate_executive_report(&self) -> Result<EnvironmentalReport> {
        let mut report = self.generate_monthly_report().await?;
        report.report_type = ReportType::Executive;

        // Focus on high-level metrics and business impact
        report.summary = "Executive Summary: Monthly environmental performance shows strong progress toward sustainability goals with measurable business benefits including cost reduction and operational efficiency gains.".to_string();

        report.detailed_analysis = "Key Business Impacts:\n\
            • $127 monthly cost savings from efficiency optimization\n\
            • 15% reduction in operational energy costs\n\
            • Improved compliance posture for environmental regulations\n\
            • Enhanced corporate sustainability credentials\n\
            • Risk mitigation for carbon pricing exposure\n\n\
            Strategic Recommendations:\n\
            • Accelerate renewable energy procurement timeline\n\
            • Invest in efficiency monitoring infrastructure\n\
            • Establish formal sustainability governance structure"
            .to_string();

        Ok(report)
    }

    async fn generate_compliance_report(&self) -> Result<EnvironmentalReport> {
        let mut report = self.generate_monthly_report().await?;
        report.report_type = ReportType::Compliance;

        // Add compliance-specific information
        report.summary = "Environmental Compliance Report: Assessment of current compliance status against environmental regulations and certification requirements.".to_string();

        report.detailed_analysis = "Compliance Status:\n\
            • ISO 14001: 65% compliance (target: 100%)\n\
            • Energy Star: 45% compliance (target: 80%)\n\
            • Carbon Trust Standard: 30% compliance (target: 90%)\n\
            • Regional emissions reporting: Fully compliant\n\
            • Energy efficiency disclosure: Fully compliant\n\n\
            Required Actions:\n\
            • Implement formal environmental management system\n\
            • Establish third-party verification processes\n\
            • Develop comprehensive carbon accounting system\n\
            • Create audit trail for all environmental metrics"
            .to_string();

        // Add compliance-specific recommendations
        report.recommendations.push(SustainabilityRecommendation {
            category: RecommendationCategory::Sustainability,
            priority: RecommendationPriority::Critical,
            title: "Accelerate compliance program implementation".to_string(),
            description: "Fast-track environmental management system implementation to meet regulatory requirements".to_string(),
            potential_impact: "Full regulatory compliance within 6 months".to_string(),
            implementation_steps: vec![
                "Engage environmental compliance consultant".to_string(),
                "Implement formal environmental management system".to_string(),
                "Establish third-party verification processes".to_string(),
                "Schedule compliance audits".to_string(),
            ],
        });

        Ok(report)
    }

    /// Retain `report` in the in-memory automated-report log, dropping the
    /// oldest once [`MAX_AUTOMATED_REPORTS`] is reached.
    fn store_automated_report(&mut self, report: &EnvironmentalReport) -> Result<()> {
        let automated_report = AutomatedReport {
            report_id: report.report_id.clone(),
            generated_at: report.generated_at,
            report_type: format!("{:?}", report.report_type),
            content: format!("{}\n\n{}", report.summary, report.detailed_analysis),
        };

        let report_id = automated_report.report_id.clone();
        self.automated_reports.push(automated_report);
        if self.automated_reports.len() > MAX_AUTOMATED_REPORTS {
            self.automated_reports.remove(0);
        }
        info!("Stored automated report: {}", report_id);
        Ok(())
    }

    /// Update dashboard metrics
    pub fn update_dashboard_metrics(&mut self, metrics: EnvironmentalDashboardMetrics) {
        self.dashboard_metrics = metrics;
    }

    /// Get current dashboard metrics
    pub fn get_dashboard_metrics(&self) -> &EnvironmentalDashboardMetrics {
        &self.dashboard_metrics
    }

    /// Get automated reports history
    pub fn get_automated_reports(&self) -> &[AutomatedReport] {
        &self.automated_reports
    }

    /// Initialize default report templates
    fn initialize_report_templates() -> HashMap<String, ReportTemplate> {
        let mut templates = HashMap::new();

        templates.insert(
            "daily_summary".to_string(),
            ReportTemplate {
                template_name: "Daily Environmental Summary".to_string(),
                target_audience: "Operations Team".to_string(),
                frequency: ReportFrequency::Daily,
                sections: vec![
                    ReportSection {
                        section_name: "Energy Consumption".to_string(),
                        metrics_included: vec![
                            "total_energy_kwh".to_string(),
                            "peak_power".to_string(),
                        ],
                        visualization_type: VisualizationType::LineChart,
                    },
                    ReportSection {
                        section_name: "Carbon Emissions".to_string(),
                        metrics_included: vec![
                            "total_co2_kg".to_string(),
                            "carbon_intensity".to_string(),
                        ],
                        visualization_type: VisualizationType::BarChart,
                    },
                ],
            },
        );

        templates.insert(
            "executive_monthly".to_string(),
            ReportTemplate {
                template_name: "Executive Monthly Report".to_string(),
                target_audience: "Executive Leadership".to_string(),
                frequency: ReportFrequency::Monthly,
                sections: vec![
                    ReportSection {
                        section_name: "Strategic Metrics".to_string(),
                        metrics_included: vec![
                            "sustainability_score".to_string(),
                            "cost_savings".to_string(),
                        ],
                        visualization_type: VisualizationType::Gauge,
                    },
                    ReportSection {
                        section_name: "Goal Progress".to_string(),
                        metrics_included: vec![
                            "carbon_goal_progress".to_string(),
                            "efficiency_goal_progress".to_string(),
                        ],
                        visualization_type: VisualizationType::Table,
                    },
                ],
            },
        );

        templates
    }

    /// Generate custom report for specific period
    pub async fn generate_custom_report(&self, period: Duration) -> Result<EnvironmentalReport> {
        let period_start = SystemTime::now() - period;
        let period_end = SystemTime::now();

        Ok(EnvironmentalReport {
            report_id: format!("custom-{}", chrono::Utc::now().format("%Y%m%d-%H%M")),
            report_type: ReportType::Summary,
            generated_at: SystemTime::now(),
            period_start,
            period_end,
            summary: format!("Custom period environmental analysis covering {:.1} days",
                           period.as_secs_f64() / (24.0 * 3600.0)),
            metrics: self.dashboard_metrics.clone(),
            detailed_analysis: "Custom period analysis showing environmental metrics and trends for the specified timeframe".to_string(),
            recommendations: vec![
                SustainabilityRecommendation {
                    category: RecommendationCategory::Performance,
                    priority: RecommendationPriority::Medium,
                    title: "Continue monitoring trends".to_string(),
                    description: "Maintain current monitoring practices and look for optimization opportunities".to_string(),
                    potential_impact: "Ongoing efficiency improvements".to_string(),
                    implementation_steps: vec![
                        "Review custom period insights".to_string(),
                        "Identify actionable optimization opportunities".to_string(),
                        "Plan implementation of improvements".to_string(),
                    ],
                },
            ],
            charts: vec![
                ChartData {
                    chart_type: VisualizationType::LineChart,
                    title: "Custom Period Energy Trend".to_string(),
                    data_points: vec![
                        ("Start".to_string(), 100.0),
                        ("Mid".to_string(), 95.5),
                        ("End".to_string(), 88.2),
                    ],
                    labels: vec!["Time".to_string(), "Energy".to_string()],
                },
            ],
        })
    }
}

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

    #[tokio::test]
    async fn generated_reports_are_really_retained() {
        let mut engine = EnvironmentalReportingEngine::new();
        assert!(engine.get_automated_reports().is_empty());

        let report = engine
            .generate_environmental_report(ReportType::Summary)
            .await
            .expect("report generation");

        // `store_automated_report` used to take `&self`, build an
        // `AutomatedReport`, log "Stored automated report: {id}" and drop it,
        // so this log stayed empty no matter how many reports were generated.
        let stored = engine.get_automated_reports();
        assert_eq!(
            stored.len(),
            1,
            "the generated report must really be retained"
        );
        assert_eq!(stored[0].report_id, report.report_id);
        assert!(stored[0].content.contains(&report.summary));
    }

    #[tokio::test]
    async fn the_automated_report_log_is_bounded() {
        let mut engine = EnvironmentalReportingEngine::new();
        for _ in 0..(MAX_AUTOMATED_REPORTS + 5) {
            engine
                .generate_environmental_report(ReportType::Summary)
                .await
                .expect("report generation");
        }
        assert_eq!(
            engine.get_automated_reports().len(),
            MAX_AUTOMATED_REPORTS,
            "the oldest reports must be dropped, not accumulated without bound"
        );
    }

    #[test]
    fn test_reporting_engine_creation() {
        let engine = EnvironmentalReportingEngine::new();
        assert!(!engine.report_templates.is_empty());
    }

    #[tokio::test]
    async fn test_daily_report_generation() {
        let engine = EnvironmentalReportingEngine::new();
        let report = engine.generate_daily_report().await.expect("async operation failed");

        assert!(!report.report_id.is_empty());
        assert!(!report.summary.is_empty());
        assert!(!report.recommendations.is_empty());
        assert!(!report.charts.is_empty());
    }

    #[tokio::test]
    async fn test_all_report_types() {
        let mut engine = EnvironmentalReportingEngine::new();

        let summary_report = engine
            .generate_environmental_report(ReportType::Summary)
            .await
            .expect("async operation failed");
        let detailed_report = engine
            .generate_environmental_report(ReportType::Detailed)
            .await
            .expect("async operation failed");
        let technical_report = engine
            .generate_environmental_report(ReportType::Technical)
            .await
            .expect("async operation failed");
        let executive_report = engine
            .generate_environmental_report(ReportType::Executive)
            .await
            .expect("async operation failed");
        let compliance_report = engine
            .generate_environmental_report(ReportType::Compliance)
            .await
            .expect("async operation failed");

        assert_eq!(summary_report.report_type, ReportType::Summary);
        assert_eq!(detailed_report.report_type, ReportType::Detailed);
        assert_eq!(technical_report.report_type, ReportType::Technical);
        assert_eq!(executive_report.report_type, ReportType::Executive);
        assert_eq!(compliance_report.report_type, ReportType::Compliance);
    }

    #[tokio::test]
    async fn test_custom_report_generation() {
        let engine = EnvironmentalReportingEngine::new();
        let custom_period = Duration::from_secs(7 * 24 * 3600); // 7 days

        let report = engine
            .generate_custom_report(custom_period)
            .await
            .expect("async operation failed");

        assert!(report.summary.contains("7.0 days"));
        assert!(!report.charts.is_empty());
    }

    #[test]
    fn test_dashboard_metrics_update() {
        let mut engine = EnvironmentalReportingEngine::new();

        let new_metrics = EnvironmentalDashboardMetrics {
            total_energy_consumed_kwh: 250.0,
            total_co2_emissions_kg: 100.0,
            current_power_usage_watts: 800.0,
            energy_efficiency_score: 0.9,
            carbon_intensity_gco2_kwh: 350.0,
            cost_per_hour_usd: 15.0,
            trend: TrendDirection::Decreasing,
        };

        engine.update_dashboard_metrics(new_metrics.clone());

        let updated_metrics = engine.get_dashboard_metrics();
        assert_eq!(updated_metrics.total_energy_consumed_kwh, 250.0);
        assert_eq!(updated_metrics.energy_efficiency_score, 0.9);
    }

    #[tokio::test]
    async fn test_report_content_quality() {
        let engine = EnvironmentalReportingEngine::new();
        let report = engine.generate_monthly_report().await.expect("async operation failed");

        // Verify report has substantive content
        assert!(report.summary.len() > 50);
        assert!(report.detailed_analysis.len() > 100);
        assert!(!report.recommendations.is_empty());

        // Verify recommendations have required fields
        for rec in &report.recommendations {
            assert!(!rec.title.is_empty());
            assert!(!rec.description.is_empty());
            assert!(!rec.implementation_steps.is_empty());
        }

        // Verify charts have data
        for chart in &report.charts {
            assert!(!chart.title.is_empty());
            assert!(!chart.data_points.is_empty());
            assert!(!chart.labels.is_empty());
        }
    }
}