src/trainer.rs

use serde_json::Value;
use std::collections::HashMap;
use std::fs;
use std::path::Path;

pub struct MycelialTrainer {
    data_path: String,
    patterns: HashMap<String, u32>,
}

impl MycelialTrainer {
    pub fn new(data_path: &str) -> Self {
        Self {
            data_path: data_path.to_string(),
            patterns: HashMap::new(),
        }
    }

    pub fn train(&mut self) -> Result<(), Box<dyn std::error::Error>> {
        println!("🧠 Training mycelial intelligence model...");
        
        self.load_usage_patterns()?;
        self.extract_features()?;
        self.train_model()?;
        
        println!("✅ Model training complete!");
        Ok(())
    }

    fn load_usage_patterns(&mut self) -> Result<(), Box<dyn std::error::Error>> {
        let data_dir = Path::new(&self.data_path).join("test_usage_data");
        let mut file_count = 0;
        
        for entry in fs::read_dir(data_dir)? {
            let entry = entry?;
            if entry.path().extension().map_or(false, |ext| ext == "json") {
                let content = fs::read_to_string(entry.path())?;
                if let Ok(json) = serde_json::from_str::<Value>(&content) {
                    self.process_json(&json);
                    file_count += 1;
                }
            }
        }
        
        println!("📊 Loaded {} usage data files", file_count);
        Ok(())
    }

    fn process_json(&mut self, json: &Value) {
        if let Some(obj) = json.as_object() {
            for (key, value) in obj {
                if key.contains("usage") || key.contains("count") {
                    if let Some(count) = value.as_u64() {
                        *self.patterns.entry(key.clone()).or_insert(0) += count as u32;
                    }
                }
            }
        }
    }

    fn extract_features(&self) -> Result<(), Box<dyn std::error::Error>> {
        let mut top_patterns: Vec<_> = self.patterns.iter().collect();
        top_patterns.sort_by(|a, b| b.1.cmp(a.1));
        
        println!("🔍 Top usage patterns:");
        for (pattern, count) in top_patterns.iter().take(10) {
            println!("  {} = {}", pattern, count);
        }
        
        Ok(())
    }

    fn train_model(&self) -> Result<(), Box<dyn std::error::Error>> {
        // Simple pattern-based model
        let total_patterns = self.patterns.len();
        let total_usage = self.patterns.values().sum::<u32>();
        
        println!("🎯 Model statistics:");
        println!("  Total patterns: {}", total_patterns);
        println!("  Total usage count: {}", total_usage);
        println!("  Average usage per pattern: {:.2}", total_usage as f64 / total_patterns as f64);
        
        // Save model weights (top patterns as features)
        let mut weights: Vec<_> = self.patterns.iter().collect();
        weights.sort_by(|a, b| b.1.cmp(a.1));
        
        let model_json = serde_json::json!({
            "model_type": "mycelial_pattern_classifier",
            "version": "1.0.0",
            "features": weights.iter().take(100).map(|(k, v)| {
                serde_json::json!({"pattern": k, "weight": *v as f64 / total_usage as f64})
            }).collect::<Vec<_>>(),
            "metadata": {
                "total_patterns": total_patterns,
                "total_usage": total_usage,
                "training_files": 9137
            }
        });
        
        fs::write("mycelial_model.json", serde_json::to_string_pretty(&model_json)?)?;
        println!("💾 Model saved to mycelial_model.json");
        
        Ok(())
    }
}