"""
Learning Loops - Learn from experience and improve over time
"""

import json
from pathlib import Path
from datetime import datetime

class LearningLoop:
    def __init__(self, data_dir="data/learning"):
        self.data_dir = Path(data_dir)
        self.data_dir.mkdir(parents=True, exist_ok=True)
        self.experiences = []
        self.knowledge = self.load_knowledge()
    
    def load_knowledge(self):
        """Load accumulated knowledge"""
        kb_file = self.data_dir / "knowledge_base.json"
        if kb_file.exists():
            with open(kb_file, 'r') as f:
                return json.load(f)
        return {
            "successful_patterns": {},
            "failed_patterns": {},
            "improvement_rate": 0.0,
            "total_experiences": 0
        }
    
    def save_knowledge(self):
        """Persist learned knowledge"""
        kb_file = self.data_dir / "knowledge_base.json"
        with open(kb_file, 'w') as f:
            json.dump(self.knowledge, f, indent=2)
    
    def record_experience(self, task_type, approach, success, outcome):
        """Record an experience for learning"""
        experience = {
            "timestamp": datetime.now().isoformat(),
            "task_type": task_type,
            "approach": approach,
            "success": success,
            "outcome": outcome
        }
        self.experiences.append(experience)
        self.knowledge["total_experiences"] += 1
        
        # Update knowledge base
        pattern_key = f"{task_type}:{approach}"
        if success:
            if pattern_key not in self.knowledge["successful_patterns"]:
                self.knowledge["successful_patterns"][pattern_key] = 0
            self.knowledge["successful_patterns"][pattern_key] += 1
        else:
            if pattern_key not in self.knowledge["failed_patterns"]:
                self.knowledge["failed_patterns"][pattern_key] = 0
            self.knowledge["failed_patterns"][pattern_key] += 1
        
        self.save_knowledge()
        return experience
    
    def get_best_approach(self, task_type):
        """Get the most successful approach for a task type"""
        candidates = {}
        
        for pattern, count in self.knowledge["successful_patterns"].items():
            if pattern.startswith(task_type + ":"):
                approach = pattern.split(":", 1)[1]
                failures = self.knowledge["failed_patterns"].get(pattern, 0)
                success_rate = count / (count + failures) if (count + failures) > 0 else 0
                candidates[approach] = {
                    "successes": count,
                    "failures": failures,
                    "success_rate": success_rate
                }
        
        if not candidates:
            return None
        
        # Return approach with highest success rate
        best = max(candidates.items(), key=lambda x: (x[1]["success_rate"], x[1]["successes"]))
        return {"approach": best[0], "stats": best[1]}
    
    def calculate_improvement(self):
        """Calculate learning improvement over time"""
        if len(self.experiences) < 10:
            return 0.0
        
        # Compare first 10 and last 10 experiences
        first_10 = self.experiences[:10]
        last_10 = self.experiences[-10:]
        
        first_success_rate = sum(1 for e in first_10 if e["success"]) / len(first_10)
        last_success_rate = sum(1 for e in last_10 if e["success"]) / len(last_10)
        
        improvement = last_success_rate - first_success_rate
        self.knowledge["improvement_rate"] = improvement
        self.save_knowledge()
        
        return improvement

if __name__ == "__main__":
    print("=" * 70)
    print("LEARNING LOOPS TEST")
    print("=" * 70)
    
    loop = LearningLoop()
    
    # Simulate experiences
    loop.record_experience("file_creation", "direct_write", True, "File created successfully")
    loop.record_experience("file_creation", "template_use", False, "Template not found")
    loop.record_experience("file_creation", "direct_write", True, "File created successfully")
    loop.record_experience("code_generation", "iterative", True, "Code works")
    
    print(f"\n📊 Total experiences: {loop.knowledge['total_experiences']}")
    
    best = loop.get_best_approach("file_creation")
    if best:
        print(f"\n🎯 Best approach for file_creation: {best['approach']}")
        print(f"   Success rate: {best['stats']['success_rate']:.1%}")
    
    print("\n✅ LEARNING LOOPS OPERATIONAL")