torsh-jit 0.1.3

//! Performance analyzer for identifying bottlenecks and hotspots

use crate::advisor::config::*;
use crate::advisor::config::{BenchmarkResults, OperationTiming};
use crate::{profiler::ProfilingSession, ComputationGraph, JitResult};
use std::collections::HashMap;

/// Performance analyzer for identifying bottlenecks and hotspots
pub struct PerformanceAnalyzer;

impl PerformanceAnalyzer {
    pub fn new() -> Self {
        Self
    }

    pub fn identify_bottlenecks(
        &self,
        benchmark_results: &BenchmarkResults,
    ) -> JitResult<Vec<PerformanceBottleneck>> {
        let mut bottlenecks = Vec::new();

        // Analyze execution times to identify bottlenecks
        for (operation, timing) in &benchmark_results.operation_timings {
            if timing.average_duration.as_millis() > 100 {
                bottlenecks.push(PerformanceBottleneck {
                    bottleneck_type: BottleneckType::Computation,
                    location: operation.clone(),
                    severity: self.calculate_bottleneck_severity(timing),
                    description: format!("Slow operation: {}", operation),
                    suggested_fixes: vec![
                        "Consider optimization or parallelization".to_string(),
                        "Profile for hotspots within the operation".to_string(),
                    ],
                });
            }
        }

        // Check memory usage patterns
        if let Some(memory_stats) = &benchmark_results.memory_statistics {
            if memory_stats.peak_usage > memory_stats.allocated * 2 {
                bottlenecks.push(PerformanceBottleneck {
                    bottleneck_type: BottleneckType::Memory,
                    location: "Global".to_string(),
                    severity: 0.8,
                    description: "High memory overhead detected".to_string(),
                    suggested_fixes: vec![
                        "Reduce memory allocations".to_string(),
                        "Implement memory pooling".to_string(),
                    ],
                });
            }
        }

        Ok(bottlenecks)
    }

    pub fn identify_hotspots(
        &self,
        benchmark_results: &BenchmarkResults,
    ) -> JitResult<Vec<PerformanceHotspot>> {
        let mut hotspots = Vec::new();
        let total_time: u64 = benchmark_results
            .operation_timings
            .values()
            .map(|timing| timing.average_duration.as_millis() as u64)
            .sum();

        if total_time == 0 {
            return Ok(hotspots);
        }

        for (operation, timing) in &benchmark_results.operation_timings {
            let time_percent =
                (timing.average_duration.as_millis() as f64 / total_time as f64) * 100.0;

            if time_percent > 10.0 {
                hotspots.push(PerformanceHotspot {
                    location: operation.clone(),
                    execution_time_percent: time_percent,
                    memory_usage_percent: 0.0, // Would need memory profiling data
                    frequency: timing.sample_count,
                    optimization_potential: self.calculate_optimization_potential(time_percent),
                });
            }
        }

        Ok(hotspots)
    }

    pub fn analyze_profiling_data(
        &self,
        profiling_session: &ProfilingSession,
    ) -> JitResult<ProfilingAnalysisResult> {
        let mut bottlenecks = Vec::new();
        let mut hotspots = Vec::new();

        // Analyze function call frequencies
        for (function, call_data) in profiling_session.function_calls() {
            if call_data.total_time_ms > 50.0 {
                bottlenecks.push(PerformanceBottleneck {
                    bottleneck_type: if call_data.memory_allocations > 1000 {
                        BottleneckType::Memory
                    } else {
                        BottleneckType::Computation
                    },
                    location: function.clone(),
                    severity: (call_data.total_time_ms / 1000.0).min(1.0),
                    description: format!("High-cost function: {}", function),
                    suggested_fixes: vec!["Profile individual operations".to_string()],
                });
            }

            let time_percent =
                call_data.total_time_ms / profiling_session.total_duration_ms() * 100.0;
            if time_percent > 5.0 {
                hotspots.push(PerformanceHotspot {
                    location: function.clone(),
                    execution_time_percent: time_percent,
                    memory_usage_percent: call_data.memory_allocations as f64
                        / profiling_session.total_allocations() as f64
                        * 100.0,
                    frequency: call_data.call_count,
                    optimization_potential: self.calculate_optimization_potential(time_percent),
                });
            }
        }

        Ok(ProfilingAnalysisResult {
            bottlenecks,
            hotspots,
        })
    }

    pub fn analyze_scalability(&self, graph: &ComputationGraph) -> JitResult<ScalabilityAnalysis> {
        let parallelization_potential = self.estimate_parallelization_potential(graph);
        let memory_scalability = self.estimate_memory_scalability(graph);
        let io_scalability = self.estimate_io_scalability(graph);
        let algorithmic_complexity = self.analyze_algorithmic_complexity(graph);

        Ok(ScalabilityAnalysis {
            parallelization_potential,
            memory_scalability,
            io_scalability,
            algorithmic_complexity,
            bottleneck_scalability: HashMap::new(),
        })
    }

    pub fn analyze_resource_utilization(
        &self,
        input: &AnalysisInput,
    ) -> JitResult<ResourceUtilization> {
        let mut cpu_usage = 0.5; // Default estimate
        let mut memory_usage = 0.3;
        let mut io_bandwidth_usage = 0.1;
        let network_usage = 0.0;
        let gpu_usage = None;

        // Analyze based on available data
        if let Some(benchmark_results) = &input.benchmark_results {
            if let Some(resource_stats) = &benchmark_results.resource_usage {
                cpu_usage = resource_stats.cpu_utilization;
                memory_usage = resource_stats.memory_utilization;
                io_bandwidth_usage = resource_stats.io_utilization;
            }
        }

        if let Some(profiling_data) = &input.profiling_data {
            // Adjust based on profiling data
            cpu_usage = (cpu_usage + profiling_data.average_cpu_usage()) / 2.0;
            memory_usage = (memory_usage
                + profiling_data.peak_memory_usage() / profiling_data.available_memory())
                / 2.0;
        }

        Ok(ResourceUtilization {
            cpu_usage,
            memory_usage,
            io_bandwidth_usage,
            network_usage,
            gpu_usage,
        })
    }

    pub fn create_execution_profile(&self, input: &AnalysisInput) -> JitResult<ExecutionProfile> {
        let total_execution_time = input
            .benchmark_results
            .as_ref()
            .map(|br| br.total_execution_time)
            .unwrap_or_else(|| std::time::Duration::from_millis(1000));

        let memory_peak_usage = input
            .benchmark_results
            .as_ref()
            .and_then(|br| br.memory_statistics.as_ref())
            .map(|ms| ms.peak_usage)
            .unwrap_or(1024 * 1024); // 1MB default

        let cpu_utilization = input
            .profiling_data
            .as_ref()
            .map(|pd| pd.average_cpu_usage())
            .unwrap_or(0.5);

        Ok(ExecutionProfile {
            total_execution_time,
            memory_peak_usage,
            cpu_utilization,
            io_operations: 0,     // Would need I/O profiling
            cache_miss_rate: 0.1, // Default estimate
        })
    }

    pub fn calculate_confidence(&self, input: &AnalysisInput) -> f64 {
        let mut confidence: f64 = 0.5; // Base confidence

        if input.benchmark_results.is_some() {
            confidence += 0.2;
        }

        if input.profiling_data.is_some() {
            confidence += 0.2;
        }

        if input.computation_graph.is_some() {
            confidence += 0.1;
        }

        confidence.min(1.0f64)
    }

    // Helper methods
    fn calculate_bottleneck_severity(&self, timing: &OperationTiming) -> f64 {
        let baseline_ms = 10.0; // 10ms baseline
        let actual_ms = timing.average_duration.as_millis() as f64;
        (actual_ms / baseline_ms).min(1.0)
    }

    fn calculate_optimization_potential(&self, time_percent: f64) -> f64 {
        // Higher time percentage means higher optimization potential
        (time_percent / 100.0).min(1.0)
    }

    fn estimate_parallelization_potential(&self, _graph: &ComputationGraph) -> f64 {
        // Simplified estimate
        0.6
    }

    fn estimate_memory_scalability(&self, _graph: &ComputationGraph) -> f64 {
        // Simplified estimate
        0.7
    }

    fn estimate_io_scalability(&self, _graph: &ComputationGraph) -> f64 {
        // Simplified estimate
        0.5
    }

    fn analyze_algorithmic_complexity(&self, graph: &ComputationGraph) -> String {
        let node_count = graph.node_count();
        match node_count {
            0..=10 => "O(1)".to_string(),
            11..=100 => "O(n)".to_string(),
            101..=1000 => "O(n log n)".to_string(),
            _ => "O(n²)".to_string(),
        }
    }
}

/// Result of profiling data analysis
#[derive(Debug)]
pub struct ProfilingAnalysisResult {
    pub bottlenecks: Vec<PerformanceBottleneck>,
    pub hotspots: Vec<PerformanceHotspot>,
}

// Helper types for function call data
#[derive(Debug)]
pub struct FunctionCallData {
    pub total_time_ms: f64,
    pub call_count: usize,
    pub memory_allocations: usize,
}

impl ProfilingSession {
    pub fn function_calls(&self) -> &HashMap<String, FunctionCallData> {
        // Implementation would depend on actual ProfilingSession structure
        static EMPTY: std::sync::LazyLock<HashMap<String, FunctionCallData>> =
            std::sync::LazyLock::new(HashMap::new);
        &EMPTY
    }

    pub fn total_duration_ms(&self) -> f64 {
        // Implementation would depend on actual ProfilingSession structure
        1000.0
    }

    pub fn total_allocations(&self) -> usize {
        // Implementation would depend on actual ProfilingSession structure
        1000
    }

    pub fn average_cpu_usage(&self) -> f64 {
        // Implementation would depend on actual ProfilingSession structure
        0.5
    }

    pub fn peak_memory_usage(&self) -> f64 {
        // Implementation would depend on actual ProfilingSession structure
        1024.0 * 1024.0
    }

    pub fn available_memory(&self) -> f64 {
        // Implementation would depend on actual ProfilingSession structure
        8.0 * 1024.0 * 1024.0 * 1024.0
    }
}