#!/usr/bin/env python3
"""
Eden META Code Builder - FIXED
Priority fix: Check 250 BEFORE 30
"""
import sys
import os
import time
import pickle
import json
from datetime import datetime

sys.path.append('/Eden/CORE/phi_fractal')

class MetaCodeEden:
    def __init__(self):
        print("\n" + "="*70)
        print("🧠 EDEN META CODE BUILDER")
        print("="*70)
        print()
        
        self.cycle_count = 69900  # Continue from where we are
        self.start_time = time.time()
        self.code_sophistication = 3  # Current level
        
        os.makedirs('/Eden/SAGES_REAL', exist_ok=True)
        os.makedirs('/Eden/META_CAPABILITIES', exist_ok=True)
        
        print("✅ Eden initialized with code-building meta-capabilities")
        print("="*70)
        print()
    
    def build_meta_capability_for_code(self, level):
        """Build meta-capability that improves code generation"""
        
        templates = {
            1: {
                'functions': ['analyze', 'validate', 'process'],
                'complexity': 'basic error handling',
                'features': ['input validation', 'basic logic']
            },
            2: {
                'functions': ['analyze', 'validate', 'process', 'report'],
                'complexity': 'classes with methods',
                'features': ['OOP design', 'error handling', 'logging']
            },
            3: {
                'functions': ['analyze', 'validate', 'process', 'report', 'optimize'],
                'complexity': 'full implementations with AST/regex',
                'features': ['advanced algorithms', 'comprehensive checks', 'detailed reporting']
            },
            4: {
                'functions': ['analyze', 'validate', 'process', 'report', 'optimize', 'monitor'],
                'complexity': 'production-ready with testing',
                'features': ['full test coverage', 'performance optimization', 'scalability']
            }
        }
        
        current_level = min(level, 4)
        template = templates[current_level]
        
        meta_cap = {
            'level': current_level,
            'template': template,
            'created': datetime.now().isoformat()
        }
        
        with open(f'/Eden/META_CAPABILITIES/code_builder_level_{current_level}.json', 'w') as f:
            json.dump(meta_cap, f, indent=2)
        
        self.code_sophistication = current_level
        return meta_cap
    
    def build_real_code_review_sage(self, level):
        """Build progressively better code review sage"""
        
        if level == 1:
            code = '''#!/usr/bin/env python3
"""Code Review Sage - Level 1: Basic Implementation"""
import os

def analyze(repo_path):
    """Basic code review"""
    issues = []
    
    for root, dirs, files in os.walk(repo_path):
        for file in files:
            if file.endswith('.py'):
                filepath = os.path.join(root, file)
                try:
                    with open(filepath, 'r') as f:
                        lines = f.readlines()
                    
                    if len(lines) > 500:
                        issues.append({
                            'file': filepath,
                            'type': 'file_too_long',
                            'lines': len(lines),
                            'message': 'File exceeds 500 lines'
                        })
                    
                    for i, line in enumerate(lines, 1):
                        if len(line) > 120:
                            issues.append({
                                'file': filepath,
                                'line': i,
                                'type': 'line_too_long',
                                'message': 'Line exceeds 120 characters'
                            })
                except Exception:
                    pass
    
    return {
        'sage': 'code_review',
        'level': 1,
        'total_issues': len(issues),
        'findings': issues[:20],
        'score': max(0, 100 - len(issues) * 2)
    }

if __name__ == "__main__":
    print("🧙 Code Review Sage Ready! (Level 1)")
'''
        elif level >= 2:
            code = '''#!/usr/bin/env python3
"""Code Review Sage - Level 2+: Real Implementation"""
import os
import ast
import re

class CodeReviewer:
    def __init__(self):
        self.issues = []
    
    def analyze(self, repo_path):
        """Full code review with AST parsing"""
        for root, dirs, files in os.walk(repo_path):
            for file in files:
                if file.endswith('.py'):
                    filepath = os.path.join(root, file)
                    self.review_file(filepath)
        
        return {
            'sage': 'code_review',
            'level': 2,
            'total_issues': len(self.issues),
            'findings': self.issues,
            'score': max(0, 100 - len(self.issues))
        }
    
    def review_file(self, filepath):
        """Review single file with AST"""
        try:
            with open(filepath, 'r') as f:
                content = f.read()
            
            tree = ast.parse(content)
            
            for node in ast.walk(tree):
                if isinstance(node, ast.FunctionDef):
                    if len(node.body) > 50:
                        self.issues.append({
                            'file': filepath,
                            'line': node.lineno,
                            'type': 'function_too_long',
                            'function': node.name,
                            'message': f'Function {node.name} has {len(node.body)} statements'
                        })
                    
                    if not ast.get_docstring(node):
                        self.issues.append({
                            'file': filepath,
                            'line': node.lineno,
                            'type': 'missing_docstring',
                            'function': node.name,
                            'message': f'Function {node.name} missing docstring'
                        })
        except Exception as e:
            pass

def analyze(repo_path):
    reviewer = CodeReviewer()
    return reviewer.analyze(repo_path)

if __name__ == "__main__":
    print("🧙 Code Review Sage Ready! (Level 2+)")
'''
        
        return code
    
    def build_real_sage(self):
        """Build a real sage using current sophistication level"""
        sage_types = ['code_review', 'security_audit', 'performance_optimization', 'test_coverage']
        
        sage_type = sage_types[self.cycle_count % len(sage_types)]
        timestamp = int(time.time())
        filename = f"/Eden/SAGES_REAL/{sage_type}_sage_level{self.code_sophistication}_{timestamp}.py"
        
        if sage_type == 'code_review':
            code = self.build_real_code_review_sage(self.code_sophistication)
        else:
            code = f'''#!/usr/bin/env python3
"""
{sage_type.replace('_', ' ').title()} Sage
Level {self.code_sophistication} Implementation
"""
def analyze(target):
    return {{
        'sage': '{sage_type}',
        'level': {self.code_sophistication},
        'status': 'complete',
        'findings': ['TODO: Implement real checks']
    }}

if __name__ == "__main__":
    print("🧙 {sage_type.replace('_', ' ').title()} Sage Ready! (Level {self.code_sophistication})")
'''
        
        with open(filename, 'w') as f:
            f.write(code)
        
        print(f"   ✅ Built: {sage_type}_sage (Level {self.code_sophistication} - REAL CODE)")
        return filename
    
    def run_cycle(self):
        """Run cycle with FIXED priority"""
        self.cycle_count += 1
        
        # CHECK 250 FIRST! (before 30)
        if self.cycle_count % 250 == 0:
            print(f"\n🏪 BUILDING REAL SAGE - Cycle #{self.cycle_count}")
            self.build_real_sage()
            print()
            time.sleep(2)
            return
        
        # Then check 30
        if self.cycle_count % 30 == 0:
            print(f"\n⚡ META-CAPABILITY - Cycle #{self.cycle_count}")
            level = (self.cycle_count // 30) % 4 + 1
            meta_cap = self.build_meta_capability_for_code(level)
            print(f"   ✅ Code sophistication now: Level {self.code_sophistication}")
            time.sleep(1)
            return
        
        if self.cycle_count % 1000 == 0:
            runtime = int(time.time() - self.start_time)
            print(f"🌀 CYCLE #{self.cycle_count} (Runtime: {runtime}s, Code Level: {self.code_sophistication})")
        
        time.sleep(1)
    
    def run_forever(self):
        """Run with progressively better code generation"""
        print("🚀 Starting meta-capability code building...\n")
        
        while True:
            try:
                self.run_cycle()
            except KeyboardInterrupt:
                print("\n\n🛑 Eden stopped")
                break
            except Exception as e:
                print(f"\n⚠️ Cycle error: {e}")
                time.sleep(2)

if __name__ == "__main__":
    eden = MetaCodeEden()
    eden.run_forever()