soma-core 2.0.1

// Issue #25 - EditClassificationSystem: Simplified implementation
// Smart classification and filtering of edit proposals

use crate::classification::{EditCategory, RiskAssessment, RiskFactor, CriticalType, SafeType, ExperimentalType, ImpactScope, ConfidenceLevel};
use crate::edit_control::{ModifiableEdit, ApprovalState};
use crate::memory::SymbolicContext;
use crate::ops::{default_operator_registry, SomaOperator};
use anyhow::{Result, anyhow};
use std::collections::HashMap;

/// Smart edit classification system with cognitive integration
pub struct EditClassificationSystem {
    /// Cognitive operators for analysis
    cognitive_operators: HashMap<String, Box<dyn SomaOperator + Send>>,
    
    /// Configuration
    config: ClassificationConfig,
}

/// Configuration for classification behavior
#[derive(Debug, Clone)]
pub struct ClassificationConfig {
    pub use_cognitive_analysis: bool,
    pub auto_classification_threshold: f64,
    pub max_batch_size: usize,
    pub verbose_logging: bool,
    pub risk_strictness: f64,
}

impl Default for ClassificationConfig {
    fn default() -> Self {
        Self {
            use_cognitive_analysis: true,
            auto_classification_threshold: 0.8,
            max_batch_size: 100,
            verbose_logging: false,
            risk_strictness: 0.7,
        }
    }
}

/// Classified edit with comprehensive analysis
#[derive(Debug, Clone)]
pub struct ClassifiedEdit {
    /// Original edit proposal
    pub edit: ModifiableEdit,
    
    /// Determined category
    pub category: EditCategory,
    
    /// Risk assessment
    pub risk_assessment: RiskAssessment,
    
    /// Priority score (0.0 = lowest, 1.0 = highest)
    pub priority_score: f64,
    
    /// Confidence in classification (0.0 = low, 1.0 = high)
    pub classification_confidence: f64,
    
    /// Cognitive analysis results (if enabled)
    pub cognitive_analysis: Option<SymbolicContext>,
    
    /// Recommended action
    pub recommendation: ClassificationRecommendation,
    
    /// Detailed reasoning
    pub reasoning: String,
}

/// Recommendation based on classification
#[derive(Debug, Clone)]
pub enum ClassificationRecommendation {
    /// Automatically approve with confidence level
    AutoApprove { confidence: f64 },
    
    /// Require manual review with specific concerns
    RequireReview { concerns: Vec<String> },
    
    /// Escalate to higher approval level
    Escalate { target_level: String, reason: String },
    
    /// Reject with explanation
    Reject { reason: String },
    
    /// Request more information
    RequestInfo { questions: Vec<String> },
}

/// Filtering criteria for classified edits
#[derive(Debug, Clone, Default)]
pub struct FilterCriteria {
    pub categories: Option<Vec<EditCategory>>,
    pub min_priority: Option<f64>,
    pub max_risk: Option<f64>,
    pub approval_states: Option<Vec<ApprovalState>>,
    pub min_confidence: Option<f64>,
}

/// Statistics about a batch of classified edits
#[derive(Debug, Clone)]
pub struct ClassificationStats {
    pub total_count: usize,
    pub category_distribution: HashMap<std::mem::Discriminant<EditCategory>, usize>,
    pub average_risk: f64,
    pub average_priority: f64,
    pub average_confidence: f64,
}

impl EditClassificationSystem {
    /// Create new classification system with default configuration
    pub fn new() -> Self {
        Self::with_config(ClassificationConfig::default())
    }
    
    /// Create new classification system with custom configuration
    pub fn with_config(config: ClassificationConfig) -> Self {
        let cognitive_operators = if config.use_cognitive_analysis {
            default_operator_registry()
        } else {
            HashMap::new()
        };
        
        Self {
            cognitive_operators,
            config,
        }
    }
    
    /// Classify a single edit proposal
    pub fn classify_edit(&self, edit: &ModifiableEdit) -> Result<ClassifiedEdit> {
        if self.config.verbose_logging {
            println!("🔍 Classifying edit: {}", edit.base_edit.file);
        }
        
        // Step 1: Determine category based on file extension
        let category = self.determine_category(edit)?;
        
        // Step 2: Assess risk
        let risk_assessment = self.assess_risk(edit, &category)?;
        
        // Step 3: Run cognitive analysis if enabled
        let cognitive_analysis = if self.config.use_cognitive_analysis {
            self.run_cognitive_analysis(edit, &category)?
        } else {
            None
        };
        
        // Step 4: Calculate priority score
        let priority_score = self.calculate_priority_score(edit, &category, &risk_assessment, &cognitive_analysis)?;
        
        // Step 5: Determine classification confidence
        let classification_confidence = self.calculate_classification_confidence(edit, &category, &risk_assessment)?;
        
        // Step 6: Generate recommendation
        let recommendation = self.generate_recommendation(&category, &risk_assessment, classification_confidence)?;
        
        // Step 7: Generate reasoning
        let reasoning = self.generate_reasoning(edit, &category, &risk_assessment, &cognitive_analysis)?;
        
        Ok(ClassifiedEdit {
            edit: edit.clone(),
            category,
            risk_assessment,
            priority_score,
            classification_confidence,
            cognitive_analysis,
            recommendation,
            reasoning,
        })
    }
    
    /// Classify multiple edits in batch with smart prioritization
    pub fn classify_batch(&self, edits: &[ModifiableEdit]) -> Result<Vec<ClassifiedEdit>> {
        if edits.len() > self.config.max_batch_size {
            return Err(anyhow!("Batch size {} exceeds maximum {}", edits.len(), self.config.max_batch_size));
        }
        
        let mut classified_edits = Vec::new();
        
        for edit in edits {
            let classified = self.classify_edit(edit)?;
            classified_edits.push(classified);
        }
        
        // Sort by priority score (highest first)
        classified_edits.sort_by(|a, b| b.priority_score.partial_cmp(&a.priority_score).unwrap_or(std::cmp::Ordering::Equal));
        
        if self.config.verbose_logging {
            println!("✅ Classified {} edits, sorted by priority", classified_edits.len());
        }
        
        Ok(classified_edits)
    }
    
    /// Filter classified edits based on criteria
    pub fn filter_edits(&self, edits: &[ClassifiedEdit], criteria: &FilterCriteria) -> Vec<&ClassifiedEdit> {
        edits.iter().filter(|edit| {
            // Filter by minimum priority
            if let Some(min_priority) = criteria.min_priority {
                if edit.priority_score < min_priority {
                    return false;
                }
            }
            
            // Filter by maximum risk
            if let Some(max_risk) = criteria.max_risk {
                if edit.risk_assessment.overall_score > max_risk {
                    return false;
                }
            }
            
            // Filter by minimum confidence
            if let Some(min_confidence) = criteria.min_confidence {
                if edit.classification_confidence < min_confidence {
                    return false;
                }
            }
            
            true
        }).collect()
    }
    
    /// Get statistics about a batch of classified edits
    pub fn get_classification_stats(&self, edits: &[ClassifiedEdit]) -> ClassificationStats {
        let total_count = edits.len();
        let mut category_counts = HashMap::new();
        let mut total_risk = 0.0;
        let mut total_priority = 0.0;
        let mut total_confidence = 0.0;
        
        for edit in edits {
            // Count categories
            let category_key = std::mem::discriminant(&edit.category);
            *category_counts.entry(category_key).or_insert(0) += 1;
            
            // Sum metrics
            total_risk += edit.risk_assessment.overall_score;
            total_priority += edit.priority_score;
            total_confidence += edit.classification_confidence;
        }
        
        ClassificationStats {
            total_count,
            category_distribution: category_counts,
            average_risk: if total_count > 0 { total_risk / total_count as f64 } else { 0.0 },
            average_priority: if total_count > 0 { total_priority / total_count as f64 } else { 0.0 },
            average_confidence: if total_count > 0 { total_confidence / total_count as f64 } else { 0.0 },
        }
    }
    
    // Private helper methods
    
    fn determine_category(&self, edit: &ModifiableEdit) -> Result<EditCategory> {
        let file_path = &edit.base_edit.file;
        
        if file_path.ends_with(".md") {
            Ok(EditCategory::Safe {
                subcategory: SafeType::Documentation,
                confidence_level: ConfidenceLevel::High,
            })
        } else if file_path.ends_with(".toml") {
            Ok(EditCategory::Critical {
                subcategory: CriticalType::DataCorruption,
                impact_scope: ImpactScope::SystemWide,
            })
        } else if file_path.contains("password") || file_path.contains("secret") {
            Ok(EditCategory::Critical {
                subcategory: CriticalType::SecurityFix,
                impact_scope: ImpactScope::SingleFile,
            })
        } else {
            Ok(EditCategory::Safe {
                subcategory: SafeType::VariableRename,
                confidence_level: ConfidenceLevel::Medium,
            })
        }
    }
    
    fn assess_risk(&self, _edit: &ModifiableEdit, category: &EditCategory) -> Result<RiskAssessment> {
        let category_risk = match category {
            EditCategory::Critical { .. } => 0.9,
            EditCategory::Experimental { .. } => 0.7,
            EditCategory::Safe { .. } => 0.2,
            EditCategory::Cosmetic { .. } => 0.1,
        };
        
        let overall_score = category_risk * self.config.risk_strictness;
        
        Ok(RiskAssessment::builder()
            .with_risk_factor(RiskFactor::ChangeComplexity, category_risk)
            .with_explanation(format!("Risk assessment: category={:.2}, overall={:.2}", 
                category_risk, overall_score))
            .with_mitigation("Review changes carefully".to_string())
            .build())
    }
    
    fn run_cognitive_analysis(&self, edit: &ModifiableEdit, category: &EditCategory) -> Result<Option<SymbolicContext>> {
        let mut context = SymbolicContext::new();
        context.set("edit_file", &edit.base_edit.file);
        context.set("edit_category", &format!("{:?}", category));
        context.set("system_performance", "optimal");
        
        // Run introspection operator
        if let Some(introspect_op) = self.cognitive_operators.get("introspect") {
            if let Ok(result) = introspect_op.execute(&context) {
                return Ok(Some(result));
            }
        }
        
        Ok(None)
    }
    
    fn calculate_priority_score(&self, _edit: &ModifiableEdit, category: &EditCategory, risk: &RiskAssessment, cognitive: &Option<SymbolicContext>) -> Result<f64> {
        let risk_score = risk.overall_score * 0.4;
        let complexity_score = (category.priority() as f64 / 4.0) * 0.3;
        let cognitive_score = if cognitive.is_some() { 0.3 } else { 0.15 };
        
        Ok(risk_score + complexity_score + cognitive_score)
    }
    
    fn calculate_classification_confidence(&self, _edit: &ModifiableEdit, category: &EditCategory, risk: &RiskAssessment) -> Result<f64> {
        let category_confidence = match category {
            EditCategory::Critical { .. } => 0.9,
            EditCategory::Safe { .. } => 0.8,
            EditCategory::Experimental { .. } => 0.6,
            EditCategory::Cosmetic { .. } => 0.95,
        };
        
        let risk_confidence = 1.0 - (risk.overall_score * 0.3);
        
        Ok((category_confidence + risk_confidence) / 2.0)
    }
    
    fn generate_recommendation(&self, category: &EditCategory, risk: &RiskAssessment, confidence: f64) -> Result<ClassificationRecommendation> {
        if risk.overall_score > 0.8 {
            return Ok(ClassificationRecommendation::RequireReview {
                concerns: vec!["High risk detected".to_string()],
            });
        }
        
        if confidence > self.config.auto_classification_threshold {
            return Ok(ClassificationRecommendation::AutoApprove { confidence });
        }
        
        match category {
            EditCategory::Critical { .. } => Ok(ClassificationRecommendation::Escalate {
                target_level: "Senior".to_string(),
                reason: "Critical change requires senior review".to_string(),
            }),
            EditCategory::Experimental { .. } => Ok(ClassificationRecommendation::RequireReview {
                concerns: vec!["Experimental change needs validation".to_string()],
            }),
            _ => Ok(ClassificationRecommendation::AutoApprove { confidence }),
        }
    }
    
    fn generate_reasoning(&self, edit: &ModifiableEdit, category: &EditCategory, risk: &RiskAssessment, cognitive: &Option<SymbolicContext>) -> Result<String> {
        let mut reasoning = String::new();
        
        reasoning.push_str(&format!("File: {}\n", edit.base_edit.file));
        reasoning.push_str(&format!("Category: {:?}\n", category));
        reasoning.push_str(&format!("Risk Score: {:.2}\n", risk.overall_score));
        reasoning.push_str(&format!("Risk Explanation: {}\n", risk.explanation));
        
        if cognitive.is_some() {
            reasoning.push_str("Cognitive analysis: Enhanced decision support enabled\n");
        }
        
        Ok(reasoning)
    }
}

impl Default for EditClassificationSystem {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::agents::gpt4_agent::ProposedEdit;
    use std::path::PathBuf;
    
    fn create_test_edit(path: &str, content: &str, reason: &str) -> ModifiableEdit {
        let proposed = ProposedEdit {
            original_file: PathBuf::from(path),
            target_file: PathBuf::from(path),
            file: path.to_string(),
            content: content.to_string(),
            reason: reason.to_string(),
            confidence: 0.8,
        };
        ModifiableEdit::from_proposed_edit(proposed)
    }
    
    #[test]
    fn test_classification_system_creation() {
        let system = EditClassificationSystem::new();
        assert!(system.config.use_cognitive_analysis);
        assert_eq!(system.config.auto_classification_threshold, 0.8);
    }
    
    #[test]
    fn test_edit_classification() {
        let system = EditClassificationSystem::new();
        let edit = create_test_edit("test.md", "# Test Documentation", "Update docs");
        
        let classified = system.classify_edit(&edit).unwrap();
        
        assert!(matches!(classified.category, EditCategory::Safe { .. }));
        assert!(classified.priority_score > 0.0);
        assert!(classified.classification_confidence > 0.0);
    }
    
    #[test]
    fn test_batch_classification() {
        let system = EditClassificationSystem::new();
        let edits = vec![
            create_test_edit("file1.md", "Documentation", "Update docs"),
            create_test_edit("file2.rs", "fn main() {}", "Add function"),
        ];
        
        let classified = system.classify_batch(&edits).unwrap();
        
        assert_eq!(classified.len(), 2);
        // Should be sorted by priority
        assert!(classified[0].priority_score >= classified[1].priority_score);
    }
    
    #[test]
    fn test_filtering() {
        let system = EditClassificationSystem::new();
        let edit = create_test_edit("test.md", "Documentation", "Update docs");
        let classified = system.classify_edit(&edit).unwrap();
        
        let mut criteria = FilterCriteria::default();
        criteria.min_priority = Some(0.0);
        
        let filtered = system.filter_edits(&[classified], &criteria);
        assert_eq!(filtered.len(), 1);
    }
    
    #[test]
    fn test_classification_stats() {
        let system = EditClassificationSystem::new();
        let edits = vec![
            create_test_edit("file1.md", "Documentation", "Update docs"),
            create_test_edit("file2.rs", "fn main() {}", "Add function"),
        ];
        
        let classified = system.classify_batch(&edits).unwrap();
        let stats = system.get_classification_stats(&classified);
        
        assert_eq!(stats.total_count, 2);
        assert!(stats.average_risk > 0.0);
        assert!(stats.average_priority > 0.0);
        assert!(stats.average_confidence > 0.0);
    }
}