kandil_code 2.1.1

use anyhow::Result;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::time::{Duration, Instant};
use tokio::time::sleep;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PerformanceReport {
    pub test_name: String,
    pub timestamp: chrono::DateTime<chrono::Utc>,
    pub duration: Duration,
    pub metrics: HashMap<String, String>,
    pub status: TestStatus,
    pub details: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum TestStatus {
    Passed,
    Failed,
    Warning,
    Skipped,
}

pub struct PerformanceTester {
    reports: Vec<PerformanceReport>,
}

impl PerformanceTester {
    pub fn new() -> Self {
        Self {
            reports: Vec::new(),
        }
    }

    /// Run comprehensive performance tests
    pub async fn run_comprehensive_tests(&mut self) -> Result<PerformanceReport> {
        let start_time = Instant::now();
        let mut metrics = HashMap::new();
        let mut status = TestStatus::Passed;
        let mut details = String::new();

        // Test 1: Startup time
        let startup_result = self.test_startup_time().await;
        if let Ok(report) = startup_result {
            self.reports.push(report);
            metrics.insert("startup_time_ms".to_string(), 
                          format!("{}", metrics.get("startup_time_ms").unwrap_or(&"0".to_string())));
        }

        // Test 2: Command execution speed
        let cmd_speed_result = self.test_command_execution_speed().await;
        if let Ok(report) = cmd_speed_result {
            self.reports.push(report);
            metrics.extend(report.metrics);
            if matches!(report.status, TestStatus::Failed) {
                status = TestStatus::Warning;
            }
        }

        // Test 3: Memory usage patterns
        let mem_usage_result = self.test_memory_usage().await;
        if let Ok(report) = mem_usage_result {
            self.reports.push(report);
            metrics.extend(report.metrics);
        }

        // Test 4: AI response latency
        let ai_latency_result = self.test_ai_response_latency().await;
        if let Ok(report) = ai_latency_result {
            self.reports.push(report);
            metrics.extend(report.metrics);
        }

        // Test 5: File I/O operations
        let io_result = self.test_file_io_performance().await;
        if let Ok(report) = io_result {
            self.reports.push(report);
            metrics.extend(report.metrics);
        }

        // Test 6: Terminal rendering performance
        let render_result = self.test_rendering_performance().await;
        if let Ok(report) = render_result {
            self.reports.push(report);
            metrics.extend(report.metrics);
        }

        let total_duration = start_time.elapsed();
        let report = PerformanceReport {
            test_name: "Comprehensive Performance Test Suite".to_string(),
            timestamp: chrono::Utc::now(),
            duration: total_duration,
            metrics,
            status,
            details: format!("Executed {} individual performance tests", self.reports.len()),
        };

        Ok(report)
    }

    /// Test startup time performance
    async fn test_startup_time(&self) -> Result<PerformanceReport> {
        let start = Instant::now();
        
        // Simulate startup operations
        for _ in 0..100 {
            // Simulate loading modules/configs
            tokio::task::yield_now().await;
        }
        
        let duration = start.elapsed();
        
        Ok(PerformanceReport {
            test_name: "Startup Time Test".to_string(),
            timestamp: chrono::Utc::now(),
            duration,
            metrics: {
                let mut map = HashMap::new();
                map.insert("startup_time_ms".to_string(), duration.as_millis().to_string());
                map.insert("modules_loaded".to_string(), "100".to_string());
                map
            },
            status: if duration.as_millis() < 1000 { TestStatus::Passed } else { TestStatus::Warning }, 
            details: "Measured time to initialize core modules".to_string(),
        })
    }

    /// Test command execution speed
    async fn test_command_execution_speed(&self) -> Result<PerformanceReport> {
        let start = Instant::now();
        
        // Execute dummy commands to measure performance
        for i in 0..1000 {
            // Simulate command execution
            let _result = self.execute_dummy_command(&format!("cmd_{}", i)).await;
            tokio::task::yield_now().await;
        }
        
        let duration = start.elapsed();
        let avg_duration = duration.as_millis() as f64 / 1000.0;
        
        Ok(PerformanceReport {
            test_name: "Command Execution Speed Test".to_string(),
            timestamp: chrono::Utc::now(),
            duration,
            metrics: {
                let mut map = HashMap::new();
                map.insert("commands_executed".to_string(), "1000".to_string());
                map.insert("average_duration_ms".to_string(), format!("{:.2}", avg_duration));
                map.insert("throughput_per_sec".to_string(), format!("{:.2}", 1000.0 / duration.as_secs_f64()));
                map
            },
            status: if avg_duration < 5.0 { TestStatus::Passed } else if avg_duration < 20.0 { TestStatus::Warning } else { TestStatus::Failed },
            details: "Average time per command execution".to_string(),
        })
    }

    /// Test memory usage
    async fn test_memory_usage(&self) -> Result<PerformanceReport> {
        use sysinfo::{System, SystemExt, ProcessExt};
        
        let mut sys = System::new_all();
        sys.refresh_all();
        let initial_memory = sys.used_memory();
        
        // Perform operations that might affect memory
        let mut test_data = Vec::new();
        for i in 0..1000 {
            test_data.push(format!("memory_test_{}", i));
        }
        
        // Allow cleanup
        std::mem::drop(test_data);
        sleep(Duration::from_millis(100)).await;
        
        sys.refresh_all();
        let final_memory = sys.used_memory();
        let memory_delta = final_memory as i64 - initial_memory as i64;
        
        Ok(PerformanceReport {
            test_name: "Memory Usage Test".to_string(),
            timestamp: chrono::Utc::now(),
            duration: Duration::from_millis(150), // Approximate
            metrics: {
                let mut map = HashMap::new();
                map.insert("initial_memory_kb".to_string(), initial_memory.to_string());
                map.insert("final_memory_kb".to_string(), final_memory.to_string());
                map.insert("memory_delta_kb".to_string(), memory_delta.to_string());
                map.insert("memory_growth_percent".to_string(), 
                          format!("{:.2}", (memory_delta as f64 / initial_memory as f64) * 100.0));
                map
            },
            status: if memory_delta < 1024 * 10 { TestStatus::Passed } else if memory_delta < 1024 * 50 { TestStatus::Warning } else { TestStatus::Failed },
            details: "Memory usage increase during operations".to_string(),
        })
    }

    /// Test AI response latency
    async fn test_ai_response_latency(&self) -> Result<PerformanceReport> {
        let start = Instant::now();
        
        // Simulate AI responses
        for _ in 0..10 {
            // Simulate AI processing time
            sleep(Duration::from_millis(50 + (rand::random::<u64>() % 100))).await; // Vary response time
        }
        
        let duration = start.elapsed();
        let avg_duration = duration.as_millis() as f64 / 10.0;
        
        Ok(PerformanceReport {
            test_name: "AI Response Latency Test".to_string(),
            timestamp: chrono::Utc::now(),
            duration,
            metrics: {
                let mut map = HashMap::new();
                map.insert("ai_calls_made".to_string(), "10".to_string());
                map.insert("average_response_ms".to_string(), format!("{:.2}", avg_duration));
                map.insert("total_ai_time_ms".to_string(), duration.as_millis().to_string());
                map
            },
            status: if avg_duration < 150.0 { TestStatus::Passed } else if avg_duration < 500.0 { TestStatus::Warning } else { TestStatus::Failed },
            details: "Average AI response time".to_string(),
        })
    }

    /// Test File I/O performance
    async fn test_file_io_performance(&self) -> Result<PerformanceReport> {
        let temp_dir = std::env::temp_dir().join("kandil_perf_test");
        std::fs::create_dir_all(&temp_dir)?;
        
        let start = Instant::now();
        
        // Write/read operations
        for i in 0..100 {
            let file_path = temp_dir.join(format!("test_file_{}.txt", i));
            let content = format!("Performance test content for file {}", i);
            
            std::fs::write(&file_path, &content)?;
            let _read_content = std::fs::read_to_string(&file_path)?;
        }
        
        let duration = start.elapsed();
        
        // Cleanup
        std::fs::remove_dir_all(&temp_dir)?;
        
        Ok(PerformanceReport {
            test_name: "File I/O Performance Test".to_string(),
            timestamp: chrono::Utc::now(),
            duration,
            metrics: {
                let mut map = HashMap::new();
                map.insert("files_processed".to_string(), "100".to_string());
                map.insert("total_io_time_ms".to_string(), duration.as_millis().to_string());
                map.insert("average_io_time_ms".to_string(), format!("{:.2}", duration.as_millis() as f64 / 100.0));
                map.insert("io_operations_per_sec".to_string(), format!("{:.2}", 100.0 / duration.as_secs_f64()));
                map
            },
            status: if duration.as_millis() < 500 { TestStatus::Passed } else if duration.as_millis() < 2000 { TestStatus::Warning } else { TestStatus::Failed },
            details: "File read/write operations performance".to_string(),
        })
    }

    /// Test terminal rendering performance
    async fn test_rendering_performance(&self) -> Result<PerformanceReport> {
        use crate::enhanced_ui::terminal::KandilTerminal;
        
        let terminal = KandilTerminal::new()?;
        
        let start = Instant::now();
        
        // Render multiple frames to test performance
        for i in 0..50 {
            // Create dummy frame content
            let frame_content = format!("Frame {} content with some text\nLine 2\nLine 3", i);
            // The terminal's internal rendering would be tested here
            // For now, we'll simulate the rendering time
            sleep(Duration::from_millis(5)).await;
        }
        
        let duration = start.elapsed();
        let avg_duration = duration.as_millis() as f64 / 50.0;
        
        Ok(PerformanceReport {
            test_name: "Terminal Rendering Performance Test".to_string(),
            timestamp: chrono::Utc::now(),
            duration,
            metrics: {
                let mut map = HashMap::new();
                map.insert("frames_rendered".to_string(), "50".to_string());
                map.insert("average_render_time_ms".to_string(), format!("{:.2}", avg_duration));
                map.insert("render_throughput_fps".to_string(), format!("{:.2}", 1000.0 / avg_duration));
                map
            },
            status: if avg_duration < 20.0 { TestStatus::Passed } else if avg_duration < 50.0 { TestStatus::Warning } else { TestStatus::Failed },
            details: "Terminal rendering performance".to_string(),
        })
    }

    /// Helper function to execute dummy commands
    async fn execute_dummy_command(&self, cmd: &str) -> String {
        // Simulate command execution
        format!("Dummy output for command: {}", cmd)
    }

    /// Generate a comprehensive performance report
    pub fn generate_report(&self) -> String {
        let mut report = String::new();
        report.push_str("=== Kandil Code Performance Report ===\n\n");
        
        // Summary statistics
        let total_tests = self.reports.len();
        let passed_tests = self.reports.iter()
            .filter(|r| matches!(r.status, TestStatus::Passed))
            .count();
        let failed_tests = self.reports.iter()
            .filter(|r| matches!(r.status, TestStatus::Failed))
            .count();
        let warning_tests = self.reports.iter()
            .filter(|r| matches!(r.status, TestStatus::Warning))
            .count();
        
        report.push_str(&format!("Total Tests Run: {}\n", total_tests));
        report.push_str(&format!("Passed: {}\n", passed_tests));
        report.push_str(&format!("Failed: {}\n", failed_tests));
        report.push_str(&format!("Warnings: {}\n", warning_tests));
        report.push_str(&format!("Success Rate: {:.1}%\n\n", (passed_tests as f64 / total_tests as f64) * 100.0));
        
        // Individual test results
        report.push_str("Individual Test Results:\n");
        for test in &self.reports {
            let status_str = match &test.status {
                TestStatus::Passed => "✅ PASSED",
                TestStatus::Failed => "❌ FAILED",
                TestStatus::Warning => "⚠️  WARNING",
                TestStatus::Skipped => "⏭️  SKIPPED",
            };
            
            report.push_str(&format!("- [{}] {}: {}ms\n", 
                                   status_str,
                                   test.test_name,
                                   test.duration.as_millis()));
            
            for (metric, value) in &test.metrics {
                report.push_str(&format!("    {}: {}\n", metric, value));
            }
            
            report.push_str(&format!("    Details: {}\n\n", test.details));
        }
        
        report
    }

    /// Run a specific benchmark test
    pub async fn run_benchmark(&self, benchmark_type: &str) -> Result<PerformanceReport> {
        match benchmark_type {
            "cpu" => self.benchmark_cpu().await,
            "memory" => self.benchmark_memory().await,
            "io" => self.benchmark_io().await,
            "ai" => self.benchmark_ai_performance().await,
            _ => {
                // Default to comprehensive test
                let start = Instant::now();
                let _ = self.run_comprehensive_tests().await?;
                let duration = start.elapsed();
                
                Ok(PerformanceReport {
                    test_name: format!("Benchmark: {}", benchmark_type),
                    timestamp: chrono::Utc::now(),
                    duration,
                    metrics: HashMap::new(),
                    status: TestStatus::Skipped, // This path shouldn't be taken normally
                    details: format!("Unknown benchmark type: {}", benchmark_type),
                })
            }
        }
    }

    async fn benchmark_cpu(&self) -> Result<PerformanceReport> {
        let start = Instant::now();
        
        // CPU-intensive operation
        let mut sum = 0;
        for i in 0..1000000 {
            sum += i ^ (i << 2) ^ (i >> 3);
        }
        
        let duration = start.elapsed();
        
        Ok(PerformanceReport {
            test_name: "CPU Benchmark".to_string(),
            timestamp: chrono::Utc::now(),
            duration,
            metrics: {
                let mut map = HashMap::new();
                map.insert("operations_completed".to_string(), "1000000".to_string());
                map.insert("compute_units".to_string(), format!("{}", sum));
                map.insert("operations_per_second".to_string(), 
                          format!("{:.2}", 1_000_000.0 / duration.as_secs_f64()));
                map
            },
            status: TestStatus::Passed,
            details: "CPU computational performance".to_string(),
        })
    }

    async fn benchmark_memory(&self) -> Result<PerformanceReport> {
        let start = Instant::now();
        
        // Memory allocation/deallocation stress test
        let mut data_blocks = Vec::new();
        for _ in 0..1000 {
            let mut block = Vec::with_capacity(1024 * 10); // 10KB blocks
            for i in 0..1024 * 10 {
                block.push(i as u8);
            }
            data_blocks.push(block);
        }
        
        // Clear all data
        std::mem::drop(data_blocks);
        
        let duration = start.elapsed();
        
        Ok(PerformanceReport {
            test_name: "Memory Benchmark".to_string(),
            timestamp: chrono::Utc::now(),
            duration,
            metrics: {
                let mut map = HashMap::new();
                map.insert("blocks_allocated".to_string(), "1000".to_string());
                map.insert("total_memory_kb".to_string(), (10 * 1000).to_string());
                map.insert("allocation_time_ms".to_string(), duration.as_millis().to_string());
                map
            },
            status: TestStatus::Passed,
            details: "Memory allocation/deallocation performance".to_string(),
        })
    }

    async fn benchmark_io(&self) -> Result<PerformanceReport> {
        let temp_dir = std::env::temp_dir().join("kandil_io_test");
        std::fs::create_dir_all(&temp_dir)?;
        
        let start = Instant::now();
        
        // Random read/write test
        for i in 0..500 {
            let file_path = temp_dir.join(format!("io_test_{}.dat", i));
            let data = vec![i as u8; 1024]; // 1KB files
            std::fs::write(&file_path, &data)?;
            let _read_data = std::fs::read(&file_path)?;
        }
        
        let duration = start.elapsed();
        
        // Cleanup
        std::fs::remove_dir_all(&temp_dir)?;
        
        Ok(PerformanceReport {
            test_name: "IO Benchmark".to_string(),
            timestamp: chrono::Utc::now(),
            duration,
            metrics: {
                let mut map = HashMap::new();
                map.insert("files_processed".to_string(), "500".to_string());
                map.insert("total_io_mb".to_string(), (500 * 1).to_string()); // 500KB = ~0.5MB
                map.insert("io_time_ms".to_string(), duration.as_millis().to_string());
                map.insert("mb_per_second".to_string(), 
                          format!("{:.2}", (500.0 * 1.0) / (duration.as_secs_f64())));
                map
            },
            status: TestStatus::Passed,
            details: "File I/O performance benchmark".to_string(),
        })
    }

    async fn benchmark_ai_performance(&self) -> Result<PerformanceReport> {
        // This would test actual AI model performance
        // For now, we'll simulate
        let start = Instant::now();
        
        for _ in 0..10 {
            // Simulate AI processing
            sleep(Duration::from_millis(100)).await;
        }
        
        let duration = start.elapsed();
        
        Ok(PerformanceReport {
            test_name: "AI Performance Benchmark".to_string(),
            timestamp: chrono::Utc::now(),
            duration,
            metrics: {
                let mut map = HashMap::new();
                map.insert("ai_requests".to_string(), "10".to_string());
                map.insert("total_processing_time_ms".to_string(), duration.as_millis().to_string());
                map.insert("avg_processing_time_ms".to_string(), 
                          format!("{:.2}", duration.as_millis() as f64 / 10.0));
                map
            },
            status: TestStatus::Passed,
            details: "AI processing performance simulation".to_string(),
        })
    }
}

// Convenience function for running performance tests
pub async fn run_performance_tests() -> Result<String> {
    let mut tester = PerformanceTester::new();
    tester.run_comprehensive_tests().await?;
    Ok(tester.generate_report())
}

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

    #[tokio::test]
    async fn test_performance_report_generation() -> Result<()> {
        let mut tester = PerformanceTester::new();
        let report = tester.run_comprehensive_tests().await?;
        assert_eq!(report.test_name, "Comprehensive Performance Test Suite");
        assert!(!tester.reports.is_empty());
        
        let report_str = tester.generate_report();
        assert!(report_str.contains("Performance Report"));
        assert!(report_str.contains("Success Rate"));
        
        Ok(())
    }

    #[tokio::test]
    async fn test_individual_benchmarks() -> Result<()> {
        let tester = PerformanceTester::new();
        
        // Test CPU benchmark
        let cpu_report = tester.benchmark_cpu().await?;
        assert!(cpu_report.duration.as_millis() > 0);
        assert_eq!(cpu_report.test_name, "CPU Benchmark");
        
        // Test memory benchmark
        let mem_report = tester.benchmark_memory().await?;
        assert_eq!(mem_report.test_name, "Memory Benchmark");
        
        Ok(())
    }
}