"""
Self-Improver - Eden analyzes and improves her own code
"""

import ast
import os
from pathlib import Path

class SelfImprover:
    def __init__(self, project_root="~/eden-agi-project"):
        self.project_root = Path(project_root).expanduser()
        self.analysis = {}
    
    def analyze_codebase(self):
        """Analyze all Python files"""
        stats = {
            "total_files": 0,
            "total_lines": 0,
            "functions": 0,
            "classes": 0,
            "todos": []
        }
        
        for py_file in self.project_root.rglob("*.py"):
            if "__pycache__" in str(py_file):
                continue
            
            stats["total_files"] += 1
            
            try:
                with open(py_file, 'r') as f:
                    content = f.read()
                    stats["total_lines"] += len(content.split('\n'))
                    
                    # Parse AST
                    tree = ast.parse(content)
                    stats["functions"] += sum(1 for node in ast.walk(tree) if isinstance(node, ast.FunctionDef))
                    stats["classes"] += sum(1 for node in ast.walk(tree) if isinstance(node, ast.ClassDef))
                    
                    # Find TODOs
                    for i, line in enumerate(content.split('\n')):
                        if 'TODO' in line or 'FIXME' in line:
                            stats["todos"].append({
                                "file": str(py_file.relative_to(self.project_root)),
                                "line": i+1,
                                "text": line.strip()
                            })
            except Exception as e:
                print(f"Error analyzing {py_file}: {e}")
        
        self.analysis = stats
        return stats
    
    def identify_bottlenecks(self):
        """Find performance bottlenecks"""
        bottlenecks = []
        
        # Simple heuristics
        if self.analysis.get("total_lines", 0) > 5000:
            bottlenecks.append("Large codebase - consider modularization")
        
        if len(self.analysis.get("todos", [])) > 10:
            bottlenecks.append(f"{len(self.analysis['todos'])} TODOs - address technical debt")
        
        return bottlenecks
    
    def propose_improvements(self):
        """Suggest code improvements"""
        improvements = []
        
        stats = self.analysis
        
        # Analyze ratios
        if stats.get("classes", 0) == 0:
            improvements.append("Add OOP structure - no classes found")
        
        if stats.get("functions", 0) / max(stats.get("total_files", 1), 1) < 3:
            improvements.append("Low function density - consider refactoring")
        
        if stats.get("todos"):
            improvements.append(f"Address {len(stats['todos'])} TODOs in codebase")
        
        return improvements
    
    def generate_improvement_plan(self):
        """Create action plan for improvements"""
        self.analyze_codebase()
        bottlenecks = self.identify_bottlenecks()
        improvements = self.propose_improvements()
        
        plan = {
            "analysis": self.analysis,
            "bottlenecks": bottlenecks,
            "improvements": improvements,
            "priority_actions": []
        }
        
        # Prioritize
        if improvements:
            plan["priority_actions"] = improvements[:3]
        
        return plan

if __name__ == "__main__":
    print("=" * 70)
    print("SELF-IMPROVER TEST")
    print("=" * 70)
    
    improver = SelfImprover()
    plan = improver.generate_improvement_plan()
    
    print(f"\n📊 Codebase Analysis:")
    print(f"   Files: {plan['analysis']['total_files']}")
    print(f"   Lines: {plan['analysis']['total_lines']}")
    print(f"   Functions: {plan['analysis']['functions']}")
    print(f"   Classes: {plan['analysis']['classes']}")
    
    print(f"\n⚠️ Bottlenecks:")
    for b in plan['bottlenecks']:
        print(f"   - {b}")
    
    print(f"\n💡 Improvements:")
    for i in plan['improvements']:
        print(f"   - {i}")
    
    print(f"\n🎯 Priority Actions:")
    for a in plan['priority_actions']:
        print(f"   - {a}")
    
    print("\n✅ SELF-IMPROVER OPERATIONAL")