trustformers_debug/

ai_code_analyzer.rs

//! Rule-Based Static Code Analysis for Model Debugging
//!
//! This module identifies potential issues in neural-network training/inference
//! source code, suggests optimizations, and flags common security anti-patterns.
//!
//! Despite the type name [`AICodeAnalyzer`] (kept for API stability), this is a
//! **deterministic, rule-based static analyzer**: every finding comes from a
//! fixed substring/pattern check against the literal source text (see
//! `AICodeAnalyzer::perform_deep_analysis` and its sibling
//! `detect_*`/`generate_*` methods), not from any trained model or live
//! inference call. There is no network access, no model weights, and no
//! non-deterministic behavior -- calling it twice on the same input always
//! produces the same result. Each rule carries a fixed `confidence: f64`
//! assigned when the rule was written, reflecting that rule's own
//! specificity (how often that particular substring pattern is a true
//! positive in practice) -- it is **not** a live-computed statistical
//! probability from any model, and must not be read as one.
// 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 anyhow::Result;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use tokio::time::{Duration, Instant};
use tracing::{debug, info};

/// Rule-based static code analysis engine for model debugging.
///
/// See the module-level docs: this is a deterministic pattern matcher, not
/// an AI model.
#[derive(Debug)]
pub struct AICodeAnalyzer {
    config: AIAnalysisConfig,
    analysis_cache: HashMap<String, CachedAnalysis>,
    pattern_database: ModelPatternDatabase,
    performance_monitor: AnalysisPerformanceMonitor,
}

/// Configuration for AI code analysis
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AIAnalysisConfig {
    /// Enable deep code analysis using AI models
    pub enable_deep_analysis: bool,
    /// Enable pattern recognition for common issues
    pub enable_pattern_recognition: bool,
    /// Enable optimization suggestions
    pub enable_optimization_suggestions: bool,
    /// Enable vulnerability detection
    pub enable_vulnerability_detection: bool,
    /// Enable performance prediction
    pub enable_performance_prediction: bool,
    /// Maximum analysis time per code segment (seconds)
    pub max_analysis_time_secs: u64,
    /// Confidence threshold for suggestions (0.0-1.0)
    pub confidence_threshold: f64,
    /// Enable caching of analysis results
    pub enable_caching: bool,
    /// Cache expiration time (hours)
    pub cache_expiration_hours: u64,
}

impl Default for AIAnalysisConfig {
    fn default() -> Self {
        Self {
            enable_deep_analysis: true,
            enable_pattern_recognition: true,
            enable_optimization_suggestions: true,
            enable_vulnerability_detection: true,
            enable_performance_prediction: true,
            max_analysis_time_secs: 30,
            confidence_threshold: 0.75,
            enable_caching: true,
            cache_expiration_hours: 24,
        }
    }
}

/// Cached analysis result
#[derive(Debug, Clone, Serialize, Deserialize)]
struct CachedAnalysis {
    result: CodeAnalysisResult,
    timestamp: std::time::SystemTime,
    code_hash: String,
}

/// Performance monitor for analysis operations
#[derive(Debug)]
struct AnalysisPerformanceMonitor {
    analysis_count: u64,
    total_analysis_time: Duration,
    cache_hits: u64,
    cache_misses: u64,
}

impl AnalysisPerformanceMonitor {
    fn new() -> Self {
        Self {
            analysis_count: 0,
            total_analysis_time: Duration::from_secs(0),
            cache_hits: 0,
            cache_misses: 0,
        }
    }

    fn record_analysis(&mut self, duration: Duration, cache_hit: bool) {
        self.analysis_count += 1;
        self.total_analysis_time += duration;
        if cache_hit {
            self.cache_hits += 1;
        } else {
            self.cache_misses += 1;
        }
    }

    fn average_analysis_time(&self) -> Duration {
        if self.analysis_count > 0 {
            self.total_analysis_time / self.analysis_count as u32
        } else {
            Duration::from_secs(0)
        }
    }

    fn cache_hit_rate(&self) -> f64 {
        let total = self.cache_hits + self.cache_misses;
        if total > 0 {
            self.cache_hits as f64 / total as f64
        } else {
            0.0
        }
    }
}

impl AICodeAnalyzer {
    /// Create a new AI code analyzer
    pub fn new(config: AIAnalysisConfig) -> Self {
        Self {
            config,
            analysis_cache: HashMap::new(),
            pattern_database: ModelPatternDatabase::new(),
            performance_monitor: AnalysisPerformanceMonitor::new(),
        }
    }

    /// Analyze model code for potential issues and optimizations
    pub async fn analyze_model_code(
        &mut self,
        code: &str,
        context: ModelContext,
    ) -> Result<CodeAnalysisResult> {
        let start_time = Instant::now();
        let code_hash = self.compute_code_hash(code);

        // Check cache first
        if self.config.enable_caching {
            if let Some(cached) = self.get_cached_analysis(&code_hash) {
                let result = cached.result.clone();
                self.performance_monitor.record_analysis(start_time.elapsed(), true);
                return Ok(result);
            }
        }

        info!(
            "Starting AI code analysis for {} lines of code",
            code.lines().count()
        );

        let mut result = CodeAnalysisResult::new();

        // Pattern recognition analysis
        if self.config.enable_pattern_recognition {
            let patterns = self.detect_code_patterns(code, &context).await?;
            result.detected_patterns = patterns;
        }

        // Deep AI analysis
        if self.config.enable_deep_analysis {
            let issues = self.perform_deep_analysis(code, &context).await?;
            result.identified_issues = issues;
        }

        // Optimization suggestions
        if self.config.enable_optimization_suggestions {
            let optimizations = self.generate_optimization_suggestions(code, &context).await?;
            result.optimization_suggestions = optimizations;
        }

        // Vulnerability detection
        if self.config.enable_vulnerability_detection {
            let vulnerabilities = self.detect_vulnerabilities(code, &context).await?;
            result.security_issues = vulnerabilities;
        }

        // Performance prediction
        if self.config.enable_performance_prediction {
            let predictions = self.predict_performance_characteristics(code, &context).await?;
            result.performance_predictions = predictions;
        }

        // Calculate overall quality score
        result.quality_score = self.calculate_quality_score(&result);
        result.analysis_metadata = AnalysisMetadata {
            analysis_duration: start_time.elapsed(),
            confidence_score: self.calculate_confidence_score(&result),
            analyzer_version: "1.0.0".to_string(),
            timestamp: std::time::SystemTime::now(),
        };

        // Cache the result
        if self.config.enable_caching {
            self.cache_analysis(code_hash, &result);
        }

        self.performance_monitor.record_analysis(start_time.elapsed(), false);

        info!(
            "AI code analysis completed in {:?} with quality score: {:.2}",
            start_time.elapsed(),
            result.quality_score
        );

        Ok(result)
    }

    /// Analyze tensor operations for optimization opportunities
    pub async fn analyze_tensor_operations(
        &self,
        operations: &[TensorOperation],
    ) -> Result<TensorOptimizationReport> {
        debug!("Analyzing {} tensor operations", operations.len());

        let mut report = TensorOptimizationReport::new();

        // Analyze operation patterns
        report.fusion_opportunities = self.detect_fusion_opportunities(operations).await?;
        report.memory_optimizations = self.detect_memory_optimizations(operations).await?;
        report.parallelization_opportunities =
            self.detect_parallelization_opportunities(operations).await?;
        report.redundant_operations = self.detect_redundant_operations(operations).await?;

        // Calculate potential speedup
        report.estimated_speedup = self.estimate_optimization_speedup(&report);
        report.estimated_memory_savings = self.estimate_memory_savings(&report);

        Ok(report)
    }

    /// Perform automated debugging assistance
    pub async fn automated_debugging_assistance(
        &self,
        error_context: &ErrorContext,
    ) -> Result<DebuggingAssistance> {
        info!(
            "Providing automated debugging assistance for error: {}",
            error_context.error_type
        );

        let mut assistance = DebuggingAssistance::new();

        // Analyze error patterns
        assistance.probable_causes = self.analyze_error_patterns(error_context).await?;
        assistance.suggested_fixes = self.generate_suggested_fixes(error_context).await?;
        assistance.debugging_steps = self.generate_debugging_steps(error_context).await?;
        assistance.related_documentation = self.find_related_documentation(error_context).await?;

        // Generate confidence score
        assistance.confidence_score = self.calculate_debugging_confidence(&assistance);

        Ok(assistance)
    }

    /// Get analysis performance metrics
    pub fn get_performance_metrics(&self) -> AnalysisPerformanceMetrics {
        AnalysisPerformanceMetrics {
            total_analyses: self.performance_monitor.analysis_count,
            average_analysis_time: self.performance_monitor.average_analysis_time(),
            cache_hit_rate: self.performance_monitor.cache_hit_rate(),
            cached_results: self.analysis_cache.len(),
        }
    }

    // Private helper methods

    async fn detect_code_patterns(
        &self,
        code: &str,
        context: &ModelContext,
    ) -> Result<Vec<DetectedPattern>> {
        debug!("Detecting code patterns");

        let mut patterns = Vec::new();

        // Common anti-patterns in neural networks
        if code.contains("torch.cuda.empty_cache()") && context.model_type == ModelType::Production
        {
            patterns.push(DetectedPattern {
                pattern_type: PatternType::AntiPattern,
                name: "Frequent CUDA Cache Clearing".to_string(),
                description: "Frequent CUDA cache clearing can hurt performance".to_string(),
                severity: Severity::Medium,
                confidence: 0.85,
                recommendations: vec![
                    "Consider using gradient accumulation instead".to_string(),
                    "Review memory management strategy".to_string(),
                ],
            });
        }

        // Gradient explosion patterns
        if code.contains("grad_norm") && code.contains("clip") {
            patterns.push(DetectedPattern {
                pattern_type: PatternType::GoodPattern,
                name: "Gradient Clipping".to_string(),
                description: "Proper gradient clipping implementation detected".to_string(),
                severity: Severity::Info,
                confidence: 0.9,
                recommendations: vec!["Consider adaptive gradient clipping".to_string()],
            });
        }

        // Memory inefficient patterns
        if code.contains("detach()") && code.contains("requires_grad") {
            patterns.push(DetectedPattern {
                pattern_type: PatternType::OptimizationOpportunity,
                name: "Gradient Computation Inefficiency".to_string(),
                description: "Potential inefficient gradient computation detected".to_string(),
                severity: Severity::Medium,
                confidence: 0.75,
                recommendations: vec![
                    "Consider using torch.no_grad() context".to_string(),
                    "Review gradient requirements".to_string(),
                ],
            });
        }

        Ok(patterns)
    }

    /// Rule-based issue detection over the literal source text. See the
    /// module docs: this is real pattern matching, not a live model call,
    /// so there is no analysis latency to simulate here.
    async fn perform_deep_analysis(
        &self,
        code: &str,
        _context: &ModelContext,
    ) -> Result<Vec<IdentifiedIssue>> {
        debug!("Performing rule-based deep code analysis");

        let mut issues = Vec::new();

        // Check for numerical stability issues
        if code.contains("log") && !code.contains("log1p") && code.contains("softmax") {
            issues.push(IdentifiedIssue {
                issue_type: IssueType::NumericalStability,
                title: "Potential Numerical Instability in Log-Softmax".to_string(),
                description: "Using log(softmax(x)) can cause numerical instability. Consider using log_softmax directly.".to_string(),
                severity: Severity::High,
                confidence: 0.88,
                suggested_fix: "Replace log(softmax(x)) with log_softmax(x)".to_string(),
                code_location: locate_in_code(code, "softmax"),
            });
        }

        // Check for inefficient attention implementations
        if code.contains("attention") && code.contains("matmul") && !code.contains("flash") {
            issues.push(IdentifiedIssue {
                issue_type: IssueType::Performance,
                title: "Inefficient Attention Implementation".to_string(),
                description:
                    "Standard attention implementation may be inefficient for large sequences."
                        .to_string(),
                severity: Severity::Medium,
                confidence: 0.75,
                suggested_fix:
                    "Consider using Flash Attention or other optimized attention mechanisms"
                        .to_string(),
                code_location: locate_in_code(code, "attention"),
            });
        }

        // Check for memory leaks
        if code.contains("accumulate") && !code.contains("zero_grad") {
            issues.push(IdentifiedIssue {
                issue_type: IssueType::MemoryLeak,
                title: "Potential Gradient Accumulation Memory Leak".to_string(),
                description: "Gradient accumulation without zero_grad() can cause memory leaks."
                    .to_string(),
                severity: Severity::High,
                confidence: 0.82,
                suggested_fix: "Ensure optimizer.zero_grad() is called appropriately".to_string(),
                code_location: locate_in_code(code, "accumulate"),
            });
        }

        Ok(issues)
    }

    async fn generate_optimization_suggestions(
        &self,
        code: &str,
        context: &ModelContext,
    ) -> Result<Vec<OptimizationSuggestion>> {
        debug!("Generating optimization suggestions");

        let mut suggestions = Vec::new();

        // Suggest mixed precision training
        if context.model_type == ModelType::Training && !code.contains("autocast") {
            suggestions.push(OptimizationSuggestion {
                optimization_type: OptimizationType::MixedPrecision,
                title: "Enable Mixed Precision Training".to_string(),
                description: "Mixed precision training can significantly speed up training and reduce memory usage.".to_string(),
                potential_speedup: 1.5,
                memory_savings: 0.4,
                implementation_effort: ImplementationEffort::Low,
                confidence: 0.9,
                code_example: Some("with torch.autocast(device_type='cuda', dtype=torch.float16):".to_string()),
            });
        }

        // Suggest model compilation
        if context.model_type == ModelType::Production && !code.contains("compile") {
            suggestions.push(OptimizationSuggestion {
                optimization_type: OptimizationType::ModelCompilation,
                title: "Enable Model Compilation".to_string(),
                description: "Model compilation can provide significant inference speedups."
                    .to_string(),
                potential_speedup: 2.0,
                memory_savings: 0.0,
                implementation_effort: ImplementationEffort::Low,
                confidence: 0.85,
                code_example: Some("model = torch.compile(model)".to_string()),
            });
        }

        // Suggest gradient checkpointing for large models
        if context.model_size > 1_000_000_000 && !code.contains("checkpoint") {
            suggestions.push(OptimizationSuggestion {
                optimization_type: OptimizationType::MemoryOptimization,
                title: "Enable Gradient Checkpointing".to_string(),
                description:
                    "Gradient checkpointing can significantly reduce memory usage for large models."
                        .to_string(),
                potential_speedup: 0.8, // Slight speed penalty
                memory_savings: 0.6,
                implementation_effort: ImplementationEffort::Medium,
                confidence: 0.88,
                code_example: Some("torch.utils.checkpoint.checkpoint(layer, x)".to_string()),
            });
        }

        Ok(suggestions)
    }

    async fn detect_vulnerabilities(
        &self,
        code: &str,
        context: &ModelContext,
    ) -> Result<Vec<SecurityIssue>> {
        debug!("Detecting security vulnerabilities");

        let mut vulnerabilities = Vec::new();

        // Check for unsafe pickle loading
        if code.contains("pickle.load") && !code.contains("safe_load") {
            vulnerabilities.push(SecurityIssue {
                vulnerability_type: VulnerabilityType::CodeExecution,
                title: "Unsafe Pickle Loading".to_string(),
                description:
                    "Loading pickle files can execute arbitrary code. Use safe alternatives."
                        .to_string(),
                severity: Severity::Critical,
                confidence: 0.95,
                mitigation: "Use torch.load with weights_only=True or safetensors".to_string(),
                cve_references: vec!["CWE-502".to_string()],
            });
        }

        // Check for model parameter exposure
        if code.contains("state_dict")
            && code.contains("save")
            && context.model_type == ModelType::Production
        {
            vulnerabilities.push(SecurityIssue {
                vulnerability_type: VulnerabilityType::DataExposure,
                title: "Potential Model Parameter Exposure".to_string(),
                description: "Saving full model state may expose sensitive parameters.".to_string(),
                severity: Severity::Medium,
                confidence: 0.7,
                mitigation: "Consider differential privacy or parameter encryption".to_string(),
                cve_references: vec![],
            });
        }

        // Check for input validation
        if code.contains("input") && !code.contains("validate") && !code.contains("sanitize") {
            vulnerabilities.push(SecurityIssue {
                vulnerability_type: VulnerabilityType::InputValidation,
                title: "Missing Input Validation".to_string(),
                description: "Input validation is important for preventing adversarial attacks."
                    .to_string(),
                severity: Severity::Medium,
                confidence: 0.65,
                mitigation: "Implement input validation and sanitization".to_string(),
                cve_references: vec![],
            });
        }

        Ok(vulnerabilities)
    }

    /// Rule-based performance prediction. Like [`Self::perform_deep_analysis`],
    /// this is real (if heuristic) computation over `code`/`context`, not a
    /// model call, so there is no latency to simulate.
    async fn predict_performance_characteristics(
        &self,
        code: &str,
        context: &ModelContext,
    ) -> Result<PerformancePredictions> {
        debug!("Predicting performance characteristics");

        let mut predictions = PerformancePredictions::new();

        // Predict memory usage based on model architecture
        predictions.estimated_memory_usage = self.estimate_memory_usage(code, context);
        predictions.estimated_training_time = self.estimate_training_time(code, context);
        predictions.estimated_inference_latency = self.estimate_inference_latency(code, context);
        predictions.scaling_characteristics = self.predict_scaling_behavior(code, context);

        // Real, code/context-dependent bottleneck signals: each entry only
        // appears when the pattern it describes was actually detected. The
        // old implementation emitted both strings unconditionally,
        // regardless of what `code`/`context` actually contained.
        let mut signal_count: u32 = 0;
        if code.contains("attention") && !code.contains("flash") {
            predictions.predicted_bottlenecks.push(
                "Attention computation may become a bottleneck for long sequences (no Flash \
                 Attention detected in this code)"
                    .to_string(),
            );
            signal_count += 1;
        }
        if context.model_size > 1_000_000_000 {
            predictions.predicted_bottlenecks.push(
                "Memory bandwidth may limit performance for large batch sizes (model exceeds \
                 1B parameters)"
                    .to_string(),
            );
            signal_count += 1;
        }

        // Confidence reflects how many independent real signals were
        // found: an honest `0.0` ("no basis for a bottleneck prediction")
        // when none matched, scaling up with corroborating signals. Never
        // the old fixed `0.75` regardless of input.
        predictions.confidence_score = match signal_count {
            0 => 0.0,
            1 => 0.6,
            _ => 0.75,
        };

        Ok(predictions)
    }

    async fn detect_fusion_opportunities(
        &self,
        operations: &[TensorOperation],
    ) -> Result<Vec<FusionOpportunity>> {
        let mut opportunities = Vec::new();

        // Detect MatMul + Add fusion (GEMM)
        for window in operations.windows(2) {
            if let [op1, op2] = window {
                if matches!(op1.op_type, OperationType::MatMul)
                    && matches!(op2.op_type, OperationType::Add)
                {
                    opportunities.push(FusionOpportunity {
                        operations: vec![op1.clone(), op2.clone()],
                        fusion_type: FusionType::GEMM,
                        estimated_speedup: 1.3,
                        description: "MatMul + Add can be fused into GEMM operation".to_string(),
                    });
                }
            }
        }

        // Detect activation fusion opportunities
        for window in operations.windows(2) {
            if let [op1, op2] = window {
                if matches!(op1.op_type, OperationType::Linear)
                    && matches!(op2.op_type, OperationType::Activation)
                {
                    opportunities.push(FusionOpportunity {
                        operations: vec![op1.clone(), op2.clone()],
                        fusion_type: FusionType::LinearActivation,
                        estimated_speedup: 1.2,
                        description: "Linear + Activation can be fused".to_string(),
                    });
                }
            }
        }

        Ok(opportunities)
    }

    async fn detect_memory_optimizations(
        &self,
        operations: &[TensorOperation],
    ) -> Result<Vec<MemoryOptimization>> {
        let mut optimizations = Vec::new();

        // Detect in-place operation opportunities
        for op in operations {
            if op.can_be_inplace() && !op.is_inplace {
                optimizations.push(MemoryOptimization {
                    operation: op.clone(),
                    optimization_type: MemoryOptimizationType::InPlace,
                    memory_savings: op.output_size_bytes,
                    description: format!("Operation {} can be performed in-place", op.name),
                });
            }
        }

        // Detect tensor reuse opportunities
        let mut tensor_usage = HashMap::new();
        for op in operations {
            for input in &op.inputs {
                *tensor_usage.entry(input.clone()).or_insert(0) += 1;
            }
        }

        for (tensor, usage_count) in tensor_usage {
            if usage_count == 1 {
                optimizations.push(MemoryOptimization {
                    operation: TensorOperation::default(),
                    optimization_type: MemoryOptimizationType::TensorReuse,
                    memory_savings: 0, // Would calculate based on tensor size
                    description: format!("Tensor {} can be reused", tensor),
                });
            }
        }

        Ok(optimizations)
    }

    async fn detect_parallelization_opportunities(
        &self,
        operations: &[TensorOperation],
    ) -> Result<Vec<ParallelizationOpportunity>> {
        let mut opportunities = Vec::new();

        // Detect independent operations that can run in parallel
        for (i, op1) in operations.iter().enumerate() {
            for op2 in operations.iter().skip(i + 1) {
                if self.operations_are_independent(op1, op2) {
                    opportunities.push(ParallelizationOpportunity {
                        operations: vec![op1.clone(), op2.clone()],
                        parallelization_type: ParallelizationType::DataParallel,
                        estimated_speedup: 1.8,
                        description: "Operations can run in parallel".to_string(),
                    });
                }
            }
        }

        Ok(opportunities)
    }

    async fn detect_redundant_operations(
        &self,
        operations: &[TensorOperation],
    ) -> Result<Vec<RedundantOperation>> {
        let mut redundant = Vec::new();

        // Detect duplicate operations
        for (i, op1) in operations.iter().enumerate() {
            for (_j, op2) in operations.iter().enumerate().skip(i + 1) {
                if self.operations_are_equivalent(op1, op2) {
                    redundant.push(RedundantOperation {
                        original_operation: op1.clone(),
                        redundant_operation: op2.clone(),
                        redundancy_type: RedundancyType::Duplicate,
                        description: "Operations produce identical results".to_string(),
                    });
                }
            }
        }

        Ok(redundant)
    }

    // Analysis helper methods

    fn operations_are_independent(&self, op1: &TensorOperation, op2: &TensorOperation) -> bool {
        // Check if operations have no data dependencies
        for input1 in &op1.inputs {
            for output2 in &op2.outputs {
                if input1 == output2 {
                    return false;
                }
            }
        }
        for input2 in &op2.inputs {
            for output1 in &op1.outputs {
                if input2 == output1 {
                    return false;
                }
            }
        }
        true
    }

    fn operations_are_equivalent(&self, op1: &TensorOperation, op2: &TensorOperation) -> bool {
        op1.op_type == op2.op_type && op1.inputs == op2.inputs && op1.parameters == op2.parameters
    }

    fn compute_code_hash(&self, code: &str) -> String {
        use std::collections::hash_map::DefaultHasher;
        use std::hash::{Hash, Hasher};

        let mut hasher = DefaultHasher::new();
        code.hash(&mut hasher);
        format!("{:x}", hasher.finish())
    }

    fn get_cached_analysis(&self, code_hash: &str) -> Option<&CachedAnalysis> {
        self.analysis_cache.get(code_hash).and_then(|cached| {
            let age = std::time::SystemTime::now()
                .duration_since(cached.timestamp)
                .unwrap_or_default();

            if age.as_secs() < self.config.cache_expiration_hours * 3600 {
                Some(cached)
            } else {
                None
            }
        })
    }

    fn cache_analysis(&mut self, code_hash: String, result: &CodeAnalysisResult) {
        self.analysis_cache.insert(
            code_hash.clone(),
            CachedAnalysis {
                result: result.clone(),
                timestamp: std::time::SystemTime::now(),
                code_hash,
            },
        );
    }

    fn calculate_quality_score(&self, result: &CodeAnalysisResult) -> f64 {
        let mut score: f64 = 100.0;

        // Deduct points for issues
        for issue in &result.identified_issues {
            match issue.severity {
                Severity::Critical => score -= 20.0,
                Severity::High => score -= 10.0,
                Severity::Medium => score -= 5.0,
                Severity::Low => score -= 2.0,
                Severity::Info => score -= 0.0,
            }
        }

        // Deduct points for security issues
        for vulnerability in &result.security_issues {
            match vulnerability.severity {
                Severity::Critical => score -= 25.0,
                Severity::High => score -= 15.0,
                Severity::Medium => score -= 8.0,
                Severity::Low => score -= 3.0,
                Severity::Info => score -= 0.0,
            }
        }

        // Add points for good patterns
        for pattern in &result.detected_patterns {
            if pattern.pattern_type == PatternType::GoodPattern {
                score += 2.0;
            }
        }

        score.max(0.0).min(100.0)
    }

    fn calculate_confidence_score(&self, result: &CodeAnalysisResult) -> f64 {
        let mut total_confidence = 0.0;
        let mut count = 0;

        for issue in &result.identified_issues {
            total_confidence += issue.confidence;
            count += 1;
        }

        for pattern in &result.detected_patterns {
            total_confidence += pattern.confidence;
            count += 1;
        }

        if count > 0 {
            total_confidence / count as f64
        } else {
            1.0
        }
    }

    fn estimate_memory_usage(&self, code: &str, context: &ModelContext) -> f64 {
        // Simplified estimation based on model size and code patterns
        let base_memory = context.model_size as f64 * 4.0; // 4 bytes per parameter

        let mut multiplier = 1.0;
        if code.contains("gradient_accumulation") {
            multiplier += 0.5;
        }
        if code.contains("mixed_precision") {
            multiplier *= 0.7;
        }

        base_memory * multiplier / 1_000_000.0 // Convert to MB
    }

    fn estimate_training_time(&self, code: &str, context: &ModelContext) -> f64 {
        // Simplified estimation in minutes per epoch
        let base_time = (context.model_size as f64).log10() * 10.0;

        let mut multiplier = 1.0;
        if code.contains("mixed_precision") {
            multiplier *= 0.6;
        }
        if code.contains("gradient_checkpointing") {
            multiplier *= 1.3;
        }

        base_time * multiplier
    }

    fn estimate_inference_latency(&self, code: &str, context: &ModelContext) -> f64 {
        // Simplified estimation in milliseconds
        let base_latency = (context.model_size as f64).log10() * 5.0;

        let mut multiplier = 1.0;
        if code.contains("compile") {
            multiplier *= 0.5;
        }
        if code.contains("quantization") {
            multiplier *= 0.7;
        }

        base_latency * multiplier
    }

    fn predict_scaling_behavior(
        &self,
        _code: &str,
        context: &ModelContext,
    ) -> ScalingCharacteristics {
        ScalingCharacteristics {
            batch_size_scaling: if context.model_size > 1_000_000_000 {
                ScalingBehavior::Sublinear
            } else {
                ScalingBehavior::Linear
            },
            sequence_length_scaling: ScalingBehavior::Quadratic, // Attention is O(n²)
            model_size_scaling: ScalingBehavior::Linear,
            memory_scaling: ScalingBehavior::Linear,
        }
    }

    fn estimate_optimization_speedup(&self, report: &TensorOptimizationReport) -> f64 {
        let mut speedup = 1.0;

        for fusion in &report.fusion_opportunities {
            speedup *= fusion.estimated_speedup;
        }

        for parallel in &report.parallelization_opportunities {
            speedup *= parallel.estimated_speedup;
        }

        speedup.min(10.0) // Cap at 10x speedup
    }

    fn estimate_memory_savings(&self, report: &TensorOptimizationReport) -> f64 {
        let total_savings: u64 =
            report.memory_optimizations.iter().map(|opt| opt.memory_savings).sum();

        total_savings as f64 / 1_000_000.0 // Convert to MB
    }

    async fn analyze_error_patterns(
        &self,
        error_context: &ErrorContext,
    ) -> Result<Vec<ProbableCause>> {
        let mut causes = Vec::new();

        match error_context.error_type.as_str() {
            "OutOfMemoryError" => {
                causes.push(ProbableCause {
                    cause: "Batch size too large".to_string(),
                    probability: 0.8,
                    evidence: vec!["GPU memory limit exceeded".to_string()],
                });
                causes.push(ProbableCause {
                    cause: "Model too large for available memory".to_string(),
                    probability: 0.6,
                    evidence: vec!["Model parameter count".to_string()],
                });
            },
            "GradientExplosion" => {
                causes.push(ProbableCause {
                    cause: "Learning rate too high".to_string(),
                    probability: 0.7,
                    evidence: vec!["Gradient norm increasing rapidly".to_string()],
                });
            },
            _ => {
                causes.push(ProbableCause {
                    cause: "Unknown error pattern".to_string(),
                    probability: 0.3,
                    evidence: vec![],
                });
            },
        }

        Ok(causes)
    }

    async fn generate_suggested_fixes(
        &self,
        error_context: &ErrorContext,
    ) -> Result<Vec<SuggestedFix>> {
        let mut fixes = Vec::new();

        match error_context.error_type.as_str() {
            "OutOfMemoryError" => {
                fixes.push(SuggestedFix {
                    description: "Reduce batch size".to_string(),
                    implementation: "batch_size = batch_size // 2".to_string(),
                    confidence: 0.9,
                    estimated_impact: "Should free ~50% of memory".to_string(),
                });
                fixes.push(SuggestedFix {
                    description: "Enable gradient checkpointing".to_string(),
                    implementation: "model.gradient_checkpointing_enable()".to_string(),
                    confidence: 0.8,
                    estimated_impact: "Reduces memory by ~40% with 10-20% speed penalty"
                        .to_string(),
                });
            },
            "GradientExplosion" => {
                fixes.push(SuggestedFix {
                    description: "Add gradient clipping".to_string(),
                    implementation:
                        "torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)"
                            .to_string(),
                    confidence: 0.95,
                    estimated_impact: "Prevents gradient explosion".to_string(),
                });
            },
            _ => {},
        }

        Ok(fixes)
    }

    async fn generate_debugging_steps(
        &self,
        error_context: &ErrorContext,
    ) -> Result<Vec<DebuggingStep>> {
        let mut steps = Vec::new();

        steps.push(DebuggingStep {
            step_number: 1,
            description: "Check system resources".to_string(),
            command: Some("nvidia-smi".to_string()),
            expected_output: "GPU memory usage and availability".to_string(),
        });

        steps.push(DebuggingStep {
            step_number: 2,
            description: "Verify model configuration".to_string(),
            command: Some("print(model)".to_string()),
            expected_output: "Model architecture and parameter count".to_string(),
        });

        if error_context.error_type.as_str() == "OutOfMemoryError" {
            steps.push(DebuggingStep {
                step_number: 3,
                description: "Check tensor shapes and batch size".to_string(),
                command: Some(
                    "print(f'Batch size: {batch_size}, Input shape: {input.shape}')".to_string(),
                ),
                expected_output: "Current batch size and input dimensions".to_string(),
            });
        }

        Ok(steps)
    }

    async fn find_related_documentation(
        &self,
        error_context: &ErrorContext,
    ) -> Result<Vec<DocumentationReference>> {
        let mut references = Vec::new();

        match error_context.error_type.as_str() {
            "OutOfMemoryError" => {
                references.push(DocumentationReference {
                    title: "Memory Management Best Practices".to_string(),
                    url: "https://docs.trustformers.ai/memory-management".to_string(),
                    relevance_score: 0.95,
                });
                references.push(DocumentationReference {
                    title: "Gradient Checkpointing Guide".to_string(),
                    url: "https://docs.trustformers.ai/gradient-checkpointing".to_string(),
                    relevance_score: 0.8,
                });
            },
            "GradientExplosion" => {
                references.push(DocumentationReference {
                    title: "Training Stability Guide".to_string(),
                    url: "https://docs.trustformers.ai/training-stability".to_string(),
                    relevance_score: 0.9,
                });
            },
            _ => {},
        }

        Ok(references)
    }

    fn calculate_debugging_confidence(&self, assistance: &DebuggingAssistance) -> f64 {
        let avg_cause_probability =
            assistance.probable_causes.iter().map(|cause| cause.probability).sum::<f64>()
                / assistance.probable_causes.len().max(1) as f64;

        let avg_fix_confidence =
            assistance.suggested_fixes.iter().map(|fix| fix.confidence).sum::<f64>()
                / assistance.suggested_fixes.len().max(1) as f64;

        (avg_cause_probability + avg_fix_confidence) / 2.0
    }
}

// Supporting data structures and types

/// Model pattern database for common patterns and anti-patterns
#[derive(Debug)]
struct ModelPatternDatabase {
    patterns: HashMap<String, PatternDefinition>,
}

impl ModelPatternDatabase {
    fn new() -> Self {
        let mut patterns = HashMap::new();

        // Add common patterns
        patterns.insert(
            "gradient_clipping".to_string(),
            PatternDefinition {
                name: "Gradient Clipping".to_string(),
                pattern_type: PatternType::GoodPattern,
                keywords: vec![
                    "clip_grad_norm".to_string(),
                    "gradient".to_string(),
                    "clip".to_string(),
                ],
                severity: Severity::Info,
                description: "Proper gradient clipping prevents gradient explosion".to_string(),
            },
        );

        Self { patterns }
    }
}

#[derive(Debug, Clone)]
struct PatternDefinition {
    name: String,
    pattern_type: PatternType,
    keywords: Vec<String>,
    severity: Severity,
    description: String,
}

/// Model context for analysis
#[derive(Debug, Clone)]
pub struct ModelContext {
    pub model_type: ModelType,
    pub model_size: u64, // Number of parameters
    pub framework: String,
    pub target_hardware: String,
    pub training_stage: TrainingStage,
}

#[derive(Debug, Clone, PartialEq)]
pub enum ModelType {
    Training,
    Inference,
    Production,
    Development,
}

#[derive(Debug, Clone)]
pub enum TrainingStage {
    Training,
    Development,
    Pretraining,
    Finetuning,
    Evaluation,
    Inference,
}

/// Comprehensive code analysis result
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CodeAnalysisResult {
    pub quality_score: f64,
    pub detected_patterns: Vec<DetectedPattern>,
    pub identified_issues: Vec<IdentifiedIssue>,
    pub optimization_suggestions: Vec<OptimizationSuggestion>,
    pub security_issues: Vec<SecurityIssue>,
    pub performance_predictions: PerformancePredictions,
    pub analysis_metadata: AnalysisMetadata,
}

impl CodeAnalysisResult {
    fn new() -> Self {
        Self {
            quality_score: 0.0,
            detected_patterns: Vec::new(),
            identified_issues: Vec::new(),
            optimization_suggestions: Vec::new(),
            security_issues: Vec::new(),
            performance_predictions: PerformancePredictions::new(),
            analysis_metadata: AnalysisMetadata::default(),
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DetectedPattern {
    pub pattern_type: PatternType,
    pub name: String,
    pub description: String,
    pub severity: Severity,
    pub confidence: f64,
    pub recommendations: Vec<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum PatternType {
    GoodPattern,
    AntiPattern,
    OptimizationOpportunity,
    SecurityConcern,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IdentifiedIssue {
    pub issue_type: IssueType,
    pub title: String,
    pub description: String,
    pub severity: Severity,
    pub confidence: f64,
    pub suggested_fix: String,
    pub code_location: Option<CodeLocation>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum IssueType {
    NumericalStability,
    Performance,
    MemoryLeak,
    LogicError,
    TypeMismatch,
    ResourceLeak,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CodeLocation {
    pub file: String,
    pub line: u32,
    pub column: u32,
}

/// Real 1-indexed `(line, column)` of the first occurrence of `needle` in
/// `code`, or `None` if `needle` does not occur. `file` is a fixed sentinel
/// (`analyze_model_code` receives only a code string, not a path) --
/// callers that need a real path should overwrite `CodeLocation::file` with
/// the source file they read `code` from.
///
/// Used so [`IdentifiedIssue::code_location`] points at the text that
/// actually triggered the rule, instead of always being `None`.
fn locate_in_code(code: &str, needle: &str) -> Option<CodeLocation> {
    let byte_offset = code.find(needle)?;
    let mut line: u32 = 1;
    let mut last_newline_offset: Option<usize> = None;
    for (idx, ch) in code[..byte_offset].char_indices() {
        if ch == '\n' {
            line += 1;
            last_newline_offset = Some(idx);
        }
    }
    let column = match last_newline_offset {
        Some(nl_idx) => (byte_offset - nl_idx) as u32,
        None => byte_offset as u32 + 1,
    };

    Some(CodeLocation {
        file: "<analyzed source>".to_string(),
        line,
        column,
    })
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OptimizationSuggestion {
    pub optimization_type: OptimizationType,
    pub title: String,
    pub description: String,
    pub potential_speedup: f64,
    pub memory_savings: f64,
    pub implementation_effort: ImplementationEffort,
    pub confidence: f64,
    pub code_example: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum OptimizationType {
    MixedPrecision,
    ModelCompilation,
    MemoryOptimization,
    ComputationOptimization,
    IOOptimization,
    ParallelizationOptimization,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ImplementationEffort {
    Low,
    Medium,
    High,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SecurityIssue {
    pub vulnerability_type: VulnerabilityType,
    pub title: String,
    pub description: String,
    pub severity: Severity,
    pub confidence: f64,
    pub mitigation: String,
    pub cve_references: Vec<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum VulnerabilityType {
    CodeExecution,
    DataExposure,
    InputValidation,
    AuthenticationBypass,
    PrivilegeEscalation,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum Severity {
    Critical,
    High,
    Medium,
    Low,
    Info,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PerformancePredictions {
    pub estimated_memory_usage: f64,      // MB
    pub estimated_training_time: f64,     // minutes per epoch
    pub estimated_inference_latency: f64, // milliseconds
    pub scaling_characteristics: ScalingCharacteristics,
    pub predicted_bottlenecks: Vec<String>,
    pub confidence_score: f64,
}

impl PerformancePredictions {
    fn new() -> Self {
        Self {
            estimated_memory_usage: 0.0,
            estimated_training_time: 0.0,
            estimated_inference_latency: 0.0,
            scaling_characteristics: ScalingCharacteristics::default(),
            predicted_bottlenecks: Vec::new(),
            confidence_score: 0.0,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ScalingCharacteristics {
    pub batch_size_scaling: ScalingBehavior,
    pub sequence_length_scaling: ScalingBehavior,
    pub model_size_scaling: ScalingBehavior,
    pub memory_scaling: ScalingBehavior,
}

impl Default for ScalingCharacteristics {
    fn default() -> Self {
        Self {
            batch_size_scaling: ScalingBehavior::Linear,
            sequence_length_scaling: ScalingBehavior::Linear,
            model_size_scaling: ScalingBehavior::Linear,
            memory_scaling: ScalingBehavior::Linear,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ScalingBehavior {
    Constant,
    Linear,
    Quadratic,
    Exponential,
    Sublinear,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AnalysisMetadata {
    pub analysis_duration: Duration,
    pub confidence_score: f64,
    pub analyzer_version: String,
    pub timestamp: std::time::SystemTime,
}

impl Default for AnalysisMetadata {
    fn default() -> Self {
        Self {
            analysis_duration: Duration::from_secs(0),
            confidence_score: 0.0,
            analyzer_version: "1.0.0".to_string(),
            timestamp: std::time::SystemTime::now(),
        }
    }
}

// Tensor operation analysis types

#[derive(Debug, Clone)]
pub struct TensorOperation {
    pub name: String,
    pub op_type: OperationType,
    pub inputs: Vec<String>,
    pub outputs: Vec<String>,
    pub parameters: HashMap<String, String>,
    pub output_size_bytes: u64,
    pub is_inplace: bool,
}

impl Default for TensorOperation {
    fn default() -> Self {
        Self {
            name: String::new(),
            op_type: OperationType::Unknown,
            inputs: Vec::new(),
            outputs: Vec::new(),
            parameters: HashMap::new(),
            output_size_bytes: 0,
            is_inplace: false,
        }
    }
}

impl TensorOperation {
    fn can_be_inplace(&self) -> bool {
        matches!(
            self.op_type,
            OperationType::Add | OperationType::Mul | OperationType::Activation
        )
    }
}

#[derive(Debug, Clone, PartialEq)]
pub enum OperationType {
    MatMul,
    Add,
    Mul,
    Conv2D,
    Linear,
    Activation,
    Pooling,
    BatchNorm,
    LayerNorm,
    Attention,
    Unknown,
}

#[derive(Debug, Clone)]
pub struct TensorOptimizationReport {
    pub fusion_opportunities: Vec<FusionOpportunity>,
    pub memory_optimizations: Vec<MemoryOptimization>,
    pub parallelization_opportunities: Vec<ParallelizationOpportunity>,
    pub redundant_operations: Vec<RedundantOperation>,
    pub estimated_speedup: f64,
    pub estimated_memory_savings: f64,
}

impl TensorOptimizationReport {
    fn new() -> Self {
        Self {
            fusion_opportunities: Vec::new(),
            memory_optimizations: Vec::new(),
            parallelization_opportunities: Vec::new(),
            redundant_operations: Vec::new(),
            estimated_speedup: 1.0,
            estimated_memory_savings: 0.0,
        }
    }
}

#[derive(Debug, Clone)]
pub struct FusionOpportunity {
    pub operations: Vec<TensorOperation>,
    pub fusion_type: FusionType,
    pub estimated_speedup: f64,
    pub description: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum FusionType {
    GEMM,
    LinearActivation,
    ConvBatchNorm,
    AttentionQKV,
}

#[derive(Debug, Clone)]
pub struct MemoryOptimization {
    pub operation: TensorOperation,
    pub optimization_type: MemoryOptimizationType,
    pub memory_savings: u64,
    pub description: String,
}

#[derive(Debug, Clone)]
pub enum MemoryOptimizationType {
    InPlace,
    TensorReuse,
    MemoryPool,
    GradientCheckpointing,
}

#[derive(Debug, Clone)]
pub struct ParallelizationOpportunity {
    pub operations: Vec<TensorOperation>,
    pub parallelization_type: ParallelizationType,
    pub estimated_speedup: f64,
    pub description: String,
}

#[derive(Debug, Clone)]
pub enum ParallelizationType {
    DataParallel,
    ModelParallel,
    PipelineParallel,
    TensorParallel,
}

#[derive(Debug, Clone)]
pub struct RedundantOperation {
    pub original_operation: TensorOperation,
    pub redundant_operation: TensorOperation,
    pub redundancy_type: RedundancyType,
    pub description: String,
}

#[derive(Debug, Clone)]
pub enum RedundancyType {
    Duplicate,
    Subsumed,
    Unnecessary,
}

// Error context and debugging assistance types

#[derive(Debug, Clone)]
pub struct ErrorContext {
    pub error_type: String,
    pub error_message: String,
    pub stack_trace: Option<String>,
    pub system_info: SystemInfo,
    pub model_info: Option<ModelContext>,
}

#[derive(Debug, Clone)]
pub struct SystemInfo {
    pub gpu_memory_total: u64,
    pub gpu_memory_used: u64,
    pub cpu_count: u32,
    pub ram_total: u64,
    pub ram_used: u64,
}

#[derive(Debug, Clone)]
pub struct DebuggingAssistance {
    pub probable_causes: Vec<ProbableCause>,
    pub suggested_fixes: Vec<SuggestedFix>,
    pub debugging_steps: Vec<DebuggingStep>,
    pub related_documentation: Vec<DocumentationReference>,
    pub confidence_score: f64,
}

impl DebuggingAssistance {
    fn new() -> Self {
        Self {
            probable_causes: Vec::new(),
            suggested_fixes: Vec::new(),
            debugging_steps: Vec::new(),
            related_documentation: Vec::new(),
            confidence_score: 0.0,
        }
    }
}

#[derive(Debug, Clone)]
pub struct ProbableCause {
    pub cause: String,
    pub probability: f64,
    pub evidence: Vec<String>,
}

#[derive(Debug, Clone)]
pub struct SuggestedFix {
    pub description: String,
    pub implementation: String,
    pub confidence: f64,
    pub estimated_impact: String,
}

#[derive(Debug, Clone)]
pub struct DebuggingStep {
    pub step_number: u32,
    pub description: String,
    pub command: Option<String>,
    pub expected_output: String,
}

#[derive(Debug, Clone)]
pub struct DocumentationReference {
    pub title: String,
    pub url: String,
    pub relevance_score: f64,
}

// Performance metrics

#[derive(Debug, Serialize, Deserialize)]
pub struct AnalysisPerformanceMetrics {
    pub total_analyses: u64,
    pub average_analysis_time: Duration,
    pub cache_hit_rate: f64,
    pub cached_results: usize,
}

/// Macro for quick AI code analysis
#[macro_export]
macro_rules! ai_analyze {
    ($code:expr, $context:expr) => {{
        let mut analyzer = AICodeAnalyzer::new(AIAnalysisConfig::default());
        analyzer.analyze_model_code($code, $context).await
    }};
}

#[path = "ai_code_analyzer_tests.rs"]
mod ai_code_analyzer_tests;

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

    #[tokio::test]
    async fn test_ai_code_analyzer_creation() {
        let analyzer = AICodeAnalyzer::new(AIAnalysisConfig::default());
        assert!(analyzer.config.enable_deep_analysis);
    }

    #[tokio::test]
    async fn test_pattern_detection() {
        let mut analyzer = AICodeAnalyzer::new(AIAnalysisConfig::default());

        let code = r#"
        import torch

        def train_step(model, data):
            torch.cuda.empty_cache()  # Should trigger anti-pattern
            grad_norm = torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)  # Good pattern
            return grad_norm
        "#;

        let context = ModelContext {
            model_type: ModelType::Production,
            model_size: 1_000_000,
            framework: "PyTorch".to_string(),
            target_hardware: "CUDA".to_string(),
            training_stage: TrainingStage::Training,
        };

        let result = analyzer
            .analyze_model_code(code, context)
            .await
            .expect("async operation failed");
        assert!(!result.detected_patterns.is_empty());
    }

    #[tokio::test]
    async fn test_security_vulnerability_detection() {
        let mut analyzer = AICodeAnalyzer::new(AIAnalysisConfig::default());

        let code = r#"
        import pickle

        def load_model(path):
            with open(path, 'rb') as f:
                model = pickle.load(f)  # Should trigger security warning
            return model
        "#;

        let context = ModelContext {
            model_type: ModelType::Production,
            model_size: 1_000_000,
            framework: "PyTorch".to_string(),
            target_hardware: "CUDA".to_string(),
            training_stage: TrainingStage::Inference,
        };

        let result = analyzer
            .analyze_model_code(code, context)
            .await
            .expect("async operation failed");
        assert!(!result.security_issues.is_empty());
        assert_eq!(
            result.security_issues[0].vulnerability_type,
            VulnerabilityType::CodeExecution
        );
    }

    #[tokio::test]
    async fn test_tensor_operation_analysis() {
        let analyzer = AICodeAnalyzer::new(AIAnalysisConfig::default());

        let operations = vec![
            TensorOperation {
                name: "matmul1".to_string(),
                op_type: OperationType::MatMul,
                inputs: vec!["a".to_string(), "b".to_string()],
                outputs: vec!["c".to_string()],
                parameters: HashMap::new(),
                output_size_bytes: 1024,
                is_inplace: false,
            },
            TensorOperation {
                name: "add1".to_string(),
                op_type: OperationType::Add,
                inputs: vec!["c".to_string(), "bias".to_string()],
                outputs: vec!["d".to_string()],
                parameters: HashMap::new(),
                output_size_bytes: 1024,
                is_inplace: false,
            },
        ];

        let report = analyzer
            .analyze_tensor_operations(&operations)
            .await
            .expect("tensor operation failed");
        assert!(!report.fusion_opportunities.is_empty());
        assert_eq!(report.fusion_opportunities[0].fusion_type, FusionType::GEMM);
    }

    #[tokio::test]
    async fn test_performance_metrics() {
        let mut analyzer = AICodeAnalyzer::new(AIAnalysisConfig::default());

        // Simulate some analyses
        let code = "print('hello')";
        let context = ModelContext {
            model_type: ModelType::Development,
            model_size: 1000,
            framework: "PyTorch".to_string(),
            target_hardware: "CPU".to_string(),
            training_stage: TrainingStage::Development,
        };

        analyzer
            .analyze_model_code(code, context.clone())
            .await
            .expect("async operation failed");
        analyzer
            .analyze_model_code(code, context)
            .await
            .expect("async operation failed"); // Should hit cache

        let metrics = analyzer.get_performance_metrics();
        assert_eq!(metrics.total_analyses, 2);
        assert!(metrics.cache_hit_rate > 0.0);
    }

    #[tokio::test]
    async fn test_debugging_assistance() {
        let analyzer = AICodeAnalyzer::new(AIAnalysisConfig::default());

        let error_context = ErrorContext {
            error_type: "OutOfMemoryError".to_string(),
            error_message: "CUDA out of memory".to_string(),
            stack_trace: None,
            system_info: SystemInfo {
                gpu_memory_total: 8_000_000_000,
                gpu_memory_used: 7_500_000_000,
                cpu_count: 8,
                ram_total: 32_000_000_000,
                ram_used: 16_000_000_000,
            },
            model_info: None,
        };

        let assistance = analyzer
            .automated_debugging_assistance(&error_context)
            .await
            .expect("async operation failed");
        assert!(!assistance.probable_causes.is_empty());
        assert!(!assistance.suggested_fixes.is_empty());
        assert!(assistance.confidence_score > 0.0);
    }

    fn make_context(model_size: u64) -> ModelContext {
        ModelContext {
            model_type: ModelType::Training,
            model_size,
            framework: "PyTorch".to_string(),
            target_hardware: "CUDA".to_string(),
            training_stage: TrainingStage::Training,
        }
    }

    /// Regression test: `perform_deep_analysis` used to always set
    /// `code_location: None` ("Would be populated with actual line
    /// numbers"). It must now report the real line/column of the text that
    /// triggered the rule.
    #[tokio::test]
    async fn test_identified_issue_code_location_is_real_not_none() {
        let analyzer = AICodeAnalyzer::new(AIAnalysisConfig::default());
        let code = "def f(x):\n    return log(softmax(x))\n";
        let context = make_context(1_000);

        let issues = analyzer
            .perform_deep_analysis(code, &context)
            .await
            .expect("deep analysis should succeed");
        let issue = issues
            .iter()
            .find(|i| matches!(i.issue_type, IssueType::NumericalStability))
            .expect("the log-softmax rule should have fired");

        let location = issue
            .code_location
            .as_ref()
            .expect("code_location must be Some (a real position), not the old hardcoded None");
        // "softmax" occurs on line 2 (1-indexed), starting right after
        // "    return log(".
        assert_eq!(location.line, 2);
        assert_eq!(location.column, "    return log(".len() as u32 + 1);
    }

    /// Regression test: `predict_performance_characteristics` used to
    /// unconditionally return the same two `predicted_bottlenecks` strings
    /// and a fixed `confidence_score: 0.75` for any input whatsoever. Code
    /// with none of the underlying signals must now honestly report no
    /// bottlenecks and zero confidence.
    #[tokio::test]
    async fn test_performance_predictions_are_honest_with_no_signals() {
        let analyzer = AICodeAnalyzer::new(AIAnalysisConfig::default());
        let code = "def f(x):\n    return x + 1\n";
        let context = make_context(1_000); // well under the 1B-parameter threshold

        let predictions = analyzer
            .predict_performance_characteristics(code, &context)
            .await
            .expect("prediction should succeed");

        assert!(
            predictions.predicted_bottlenecks.is_empty(),
            "must not report bottlenecks when no real signal was detected: {:?}",
            predictions.predicted_bottlenecks
        );
        assert_eq!(
            predictions.confidence_score, 0.0,
            "must not be the old fixed 0.75 when nothing was actually detected"
        );
    }

    /// Companion to the above: with a real attention-without-flash signal
    /// present, the corresponding bottleneck must appear and confidence
    /// must be nonzero -- and the result must differ between inputs,
    /// proving these are no longer fixed constants.
    #[tokio::test]
    async fn test_performance_predictions_reflect_real_code_signals() {
        let analyzer = AICodeAnalyzer::new(AIAnalysisConfig::default());
        let attention_code = "out = attention(q, k, v, matmul_impl=True)";
        let plain_context = make_context(1_000);

        let with_attention = analyzer
            .predict_performance_characteristics(attention_code, &plain_context)
            .await
            .expect("prediction should succeed");
        assert_eq!(with_attention.predicted_bottlenecks.len(), 1);
        assert!(with_attention.predicted_bottlenecks[0].contains("Attention"));
        assert_eq!(with_attention.confidence_score, 0.6);

        let large_model_context = make_context(2_000_000_000);
        let with_both = analyzer
            .predict_performance_characteristics(attention_code, &large_model_context)
            .await
            .expect("prediction should succeed");
        assert_eq!(
            with_both.predicted_bottlenecks.len(),
            2,
            "a large model plus an attention signal must report both real bottlenecks"
        );
        assert_eq!(with_both.confidence_score, 0.75);
    }

    /// Regression test: `perform_deep_analysis` and
    /// `predict_performance_characteristics` used to sleep for 100ms/50ms
    /// each ("Simulate AI analysis") regardless of input. A full
    /// `analyze_model_code` call (which invokes both, plus every other
    /// rule pass) must now complete essentially immediately.
    #[tokio::test]
    async fn test_analyze_model_code_has_no_artificial_latency() {
        let mut analyzer = AICodeAnalyzer::new(AIAnalysisConfig::default());
        let code = "out = attention(q, k, v, matmul_impl=True)\nlog(softmax(x))";
        let context = make_context(2_000_000_000);

        let start = std::time::Instant::now();
        analyzer
            .analyze_model_code(code, context)
            .await
            .expect("analysis should succeed");
        let elapsed = start.elapsed();

        // The old sleeps alone totalled 150ms; a real rule-based pass over
        // a two-line string should take microseconds. 50ms leaves generous
        // headroom for slow CI machines while still catching a reintroduced
        // sleep.
        assert!(
            elapsed < std::time::Duration::from_millis(50),
            "analysis took {elapsed:?}; the old implementation's artificial sleeps must be gone"
        );
    }
}