soma-core 2.0.0

// CLI interface for EditClassificationSystem
// Provides interactive edit classification and filtering capabilities

use crate::classification::edit_classifier_working::{
    EditClassificationSystem, ClassifiedEdit
};
use crate::classification::types::EditCategory;
use crate::edit_control::ModifiableEdit;
use anyhow::Result;
use crossterm::{
    cursor, execute,
    style::{Color, ResetColor, SetForegroundColor},
    terminal::{Clear, ClearType},
};
use std::io::stdout;

/// Interactive CLI for edit classification
pub struct EditClassificationCLI {
    classification_system: EditClassificationSystem,
}

impl EditClassificationCLI {
    pub fn new() -> Result<Self> {
        let classification_system = EditClassificationSystem::new();
        Ok(Self { classification_system })
    }
    
    /// Main interactive classification workflow
    pub fn run_interactive_classification(&mut self, edits: Vec<ModifiableEdit>) -> Result<Vec<ClassifiedEdit>> {
        self.display_header()?;
        
        println!("🔍 Classifying {} edits with intelligent analysis...\n", edits.len());
        
        // Classify all edits
        let classified_edits = self.classification_system.classify_batch(&edits)?;
        
        // Display results
        self.display_classification_results(&classified_edits)?;
        
        Ok(classified_edits)
    }
    
    /// Classify a single edit with detailed display
    pub fn classify_single_edit(&mut self, edit: &ModifiableEdit) -> Result<ClassifiedEdit> {
        self.display_header()?;
        
        println!("🔍 Analyzing edit: {}", edit.base_edit.file);
        
        let classified = self.classification_system.classify_edit(edit)?;
        
        self.display_detailed_classification(&classified)?;
        
        Ok(classified)
    }
    
    /// Display classification system configuration
    pub fn show_configuration(&self) -> Result<()> {
        self.display_header()?;
        
        println!("⚙️  Edit Classification System Configuration");
        println!("===========================================\n");
        
        let config = self.classification_system.config();
        
        println!("🧠 Cognitive Analysis: {}", 
            if config.use_cognitive_analysis { "✅ Enabled" } else { "❌ Disabled" });
        println!("🎯 Auto-Classification Threshold: {:.1}%", 
            config.auto_classification_threshold * 100.0);
        println!("📦 Max Batch Size: {}", 
            config.max_batch_size);
        println!("📝 Verbose Logging: {}", 
            if config.verbose_logging { "✅ Enabled" } else { "❌ Disabled" });
        println!("⚠️  Risk Strictness: {:.1}%", 
            config.risk_strictness * 100.0);
        
        println!("\n📊 Pattern Database:");
        println!("   • File patterns: Rust, TOML, Markdown, JSON, YAML");
        println!("   • Security patterns: 9 patterns detected");
        println!("   • Performance patterns: 8 patterns detected");
        
        println!("\n🔢 Scoring Algorithm:");
        println!("   • Risk Weight: 40.0%");
        println!("   • Complexity Weight: 30.0%");
        println!("   • Size Weight: 20.0%");
        println!("   • Cognitive Weight: 10.0%");
        
        Ok(())
    }
    
    fn display_header(&self) -> Result<()> {
        execute!(stdout(), Clear(ClearType::All), cursor::MoveTo(0, 0))?;
        
        println!("🚀 SOMA-CORE Edit Classification System");
        println!("=====================================");
        println!("Phase 3 Development - Smart Filtering & Priority\n");
        
        Ok(())
    }
    
    fn display_classification_results(&self, classified_edits: &[ClassifiedEdit]) -> Result<()> {
        println!("📊 Classification Results:");
        println!("========================\n");
        
        // Display statistics
        let stats = self.classification_system.get_classification_stats(classified_edits);
        println!("📈 Statistics:");
        println!("   • Total Edits: {}", stats.total_count);
        println!("   • Average Risk: {:.2}", stats.average_risk);
        println!("   • Average Priority: {:.2}", stats.average_priority);
        println!("   • Average Confidence: {:.2}\n", stats.average_confidence);
        
        // Display each classified edit
        for (i, classified) in classified_edits.iter().enumerate() {
            self.display_classified_edit_summary(i + 1, classified)?;
        }
        
        Ok(())
    }
    
    fn display_classified_edit_summary(&self, index: usize, classified: &ClassifiedEdit) -> Result<()> {
        let category_color = match classified.category {
            EditCategory::Critical { .. } => Color::Red,
            EditCategory::Experimental { .. } => Color::Yellow,
            EditCategory::Safe { .. } => Color::Green,
            EditCategory::Cosmetic { .. } => Color::Blue,
        };
        
        execute!(stdout(), SetForegroundColor(category_color))?;
        print!("{}. {}", index, classified.edit.base_edit.file);
        execute!(stdout(), ResetColor)?;
        
        println!();
        println!("   📂 Category: {:?}", classified.category);
        println!("   ⚠️  Risk: {:.2}", classified.risk_assessment.overall_score);
        println!("   🎯 Priority: {:.2}", classified.priority_score);
        println!("   🔒 Confidence: {:.2}\n", classified.classification_confidence);
        
        Ok(())
    }
    
    fn display_detailed_classification(&self, classified: &ClassifiedEdit) -> Result<()> {
        println!("\n📋 Detailed Classification Analysis:");
        println!("===================================\n");
        
        println!("📂 File: {}", classified.edit.base_edit.file);
        
        println!("\n📊 Classification:");
        println!("   Category: {:?}", classified.category);
        println!("   Priority Score: {:.3}", classified.priority_score);
        println!("   Classification Confidence: {:.3}", classified.classification_confidence);
        
        println!("\n⚠️  Risk Assessment:");
        println!("   Overall Risk Score: {:.3}", classified.risk_assessment.overall_score);
        println!("   Explanation: {}", classified.risk_assessment.explanation);
        
        if let Some(ref cognitive) = classified.cognitive_analysis {
            println!("\n🧠 Cognitive Analysis:");
            for (key, value) in cognitive.flatten() {
                println!("   {}: {}", key, value);
            }
        }
        
        Ok(())
    }
}

impl Default for EditClassificationCLI {
    fn default() -> Self {
        Self::new().expect("Failed to create EditClassificationCLI")
    }
}