#!/usr/bin/env python3
# TIE Integration
try:
    from eden_tie_control import should_act, get_mode, get_limits
    TIE_ACTIVE = True
except:
    TIE_ACTIVE = False
"""
Eden Autonomous Evolution System
Continuously evolves sages: Gen 2 → Gen 3 → Gen 4...
"""
import os
import json
import time
import subprocess
from datetime import datetime
from collections import Counter

print("🌀 EDEN AUTONOMOUS EVOLUTION SYSTEM")
print("=" * 70)
print("Eden continuously reviews and improves her own sages")
print("=" * 70)
print()

# Configuration
CURRENT_GEN = 2
TARGET_GEN = 3
API_URL = "http://localhost:5001"

stats = {
    'generation': CURRENT_GEN,
    'reviews_completed': 0,
    'sages_built': 0,
    'quality_improvements': []
}

def log_evolution(msg):
    timestamp = datetime.now().isoformat()
    log_file = '/Eden/MEMORY/autonomous_evolution.log'
    with open(log_file, 'a') as f:
        f.write(f"[{timestamp}] {msg}\n")
    print(msg)

def test_sage_quality(sage_path):
    """Test a sage against real production code"""
    try:
        result = subprocess.run(
            ['python3', sage_path, '/Eden/CORE'],
            capture_output=True,
            text=True,
            timeout=30
        )
        
        output = result.stdout
        
        # Extract critical issues count
        if "'critical':" in output:
            critical = int(output.split("'critical':")[1].split(',')[0].strip())
            total = int(output.split("'total_issues':")[1].split(',')[0].strip())
            score = int(output.split("'score':")[1].split(',')[0].strip())
            
            return {
                'success': True,
                'critical': critical,
                'total': total,
                'score': score
            }
        return {'success': False}
    except Exception as e:
        return {'success': False, 'error': str(e)}

def review_current_generation():
    """Review all sages in current generation"""
    log_evolution(f"\n{'='*70}")
    log_evolution(f"📊 REVIEWING GENERATION {CURRENT_GEN}")
    log_evolution(f"{'='*70}")
    
    gen_dir = f'/Eden/SAGES_GEN{CURRENT_GEN}'
    sages = [f for f in os.listdir(gen_dir) if f.endswith('.py')]
    
    log_evolution(f"Found {len(sages)} Gen {CURRENT_GEN} sages to review")
    
    # Test sample of sages
    sample_size = min(10, len(sages))
    import random
    sample = random.sample(sages, sample_size)
    
    results = []
    for sage in sample:
        sage_path = os.path.join(gen_dir, sage)
        log_evolution(f"  Testing: {sage}...")
        
        result = test_sage_quality(sage_path)
        if result['success']:
            results.append(result)
            log_evolution(f"    Critical: {result['critical']}, Total: {result['total']}")
    
    if results:
        avg_critical = sum(r['critical'] for r in results) / len(results)
        avg_total = sum(r['total'] for r in results) / len(results)
        
        log_evolution(f"\n📈 Gen {CURRENT_GEN} Average Performance:")
        log_evolution(f"   Critical issues: {avg_critical:.0f}")
        log_evolution(f"   Total issues: {avg_total:.0f}")
        
        return {
            'avg_critical': avg_critical,
            'avg_total': avg_total,
            'sample_size': len(results)
        }
    
    return None

def identify_improvements():
    """Identify what Gen 3 should improve"""
    log_evolution(f"\n🔍 ANALYZING IMPROVEMENT OPPORTUNITIES...")
    
    # Check Gen 2 reviews if they exist
    gen2_reviews_dir = f'/Eden/SAGE_REVIEWS_GEN2'
    os.makedirs(gen2_reviews_dir, exist_ok=True)
    
    improvements = [
        'performance_optimization',
        'security_hardening', 
        'code_quality_checks',
        'architectural_analysis'
    ]
    
    log_evolution(f"   Identified {len(improvements)} improvement areas for Gen {TARGET_GEN}")
    for imp in improvements:
        log_evolution(f"     - {imp}")
    
    return improvements

def build_next_generation(improvements, baseline_quality):
    """Build Gen 3 with identified improvements"""
    log_evolution(f"\n{'='*70}")
    log_evolution(f"🚀 BUILDING GENERATION {TARGET_GEN}")
    log_evolution(f"{'='*70}")
    
    next_gen_dir = f'/Eden/SAGES_GEN{TARGET_GEN}'
    os.makedirs(next_gen_dir, exist_ok=True)
    
    # Enhanced template for Gen 3
    gen3_template = f'''#!/usr/bin/env python3
"""
Generation {TARGET_GEN} Code Review Sage
Evolution: Gen {CURRENT_GEN} → Gen {TARGET_GEN}
Baseline quality: {baseline_quality.get('avg_critical', 0):.0f} critical issues
Improvements: {', '.join(improvements)}
"""
import ast
import os
import logging
import re

logging.basicConfig(level=logging.INFO, format='%(levelname)s:%(message)s')

def analyze(repo_path):
    """Gen {TARGET_GEN} enhanced analysis"""
    critical = 0
    high = 0
    medium = 0
    low = 0
    issues = []
    
    for root, dirs, files in os.walk(repo_path):
        dirs[:] = [d for d in dirs if d not in ['venv', 'node_modules', '__pycache__', 'site-packages', '.git']]
        
        for file in files:
            if not file.endswith('.py'):
                continue
            
            filepath = os.path.join(root, file)
            try:
                with open(filepath, 'r', encoding='utf-8', errors='ignore') as f:
                    content = f.read()
                    tree = ast.parse(content)
                
                # Gen {TARGET_GEN} Enhanced Checks
                for node in ast.walk(tree):
                    if isinstance(node, ast.FunctionDef):
                        # Function length (stricter)
                        if hasattr(node, 'end_lineno'):
                            length = node.end_lineno - node.lineno
                            if length > 100:
                                critical += 1
                            elif length > 50:
                                high += 1
                        
                        # Complexity (more detailed)
                        complexity = len([n for n in ast.walk(node) 
                                        if isinstance(n, (ast.If, ast.While, ast.For))])
                        if complexity > 15:
                            critical += 1
                        elif complexity > 10:
                            high += 1
                        elif complexity > 5:
                            medium += 1
                        
                        # Docstring check
                        if not ast.get_docstring(node):
                            medium += 1
                        
                        # Parameter count (stricter)
                        param_count = len(node.args.args)
                        if param_count > 10:
                            critical += 1
                        elif param_count > 7:
                            high += 1
                        elif param_count > 5:
                            medium += 1
                        
                        # Security checks
                        for child in ast.walk(node):
                            if isinstance(child, ast.Call):
                                if isinstance(child.func, ast.Name):
                                    # Dangerous functions
                                    if child.func.id in ['eval', 'exec']:
                                        critical += 1
                                        issues.append(f"{{filepath}}:{{child.lineno}} - CRITICAL: {{child.func.id}}() usage")
                                    
                                    # Potential SQL injection
                                    if child.func.id in ['execute', 'executemany']:
                                        high += 1
                                        issues.append(f"{{filepath}}:{{child.lineno}} - HIGH: SQL execution - check for injection")
                
                # File-level checks
                # Check for hardcoded secrets (Gen 3 improvement)
                secret_patterns = [
                    (r'password\\s*=\\s*["\'][^"\']+["\']', 'hardcoded password'),
                    (r'api[_-]?key\\s*=\\s*["\'][^"\']+["\']', 'hardcoded API key'),
                    (r'secret\\s*=\\s*["\'][^"\']+["\']', 'hardcoded secret'),
                    (r'token\\s*=\\s*["\'][^"\']+["\']', 'hardcoded token'),
                ]
                
                for pattern, desc in secret_patterns:
                    if re.search(pattern, content, re.IGNORECASE):
                        critical += 1
                        issues.append(f"{{filepath}} - CRITICAL: {{desc}}")
            
            except SyntaxError as e:
                logging.warning(f"Syntax error in {{filepath}}: {{e}}")
            except Exception as e:
                logging.error(f"Error analyzing {{filepath}}: {{e}}")
    
    total_issues = critical + high + medium + low
    score = max(0, 100 - critical * 3 - high * 2 - medium * 1)
    
    return {{
        'sage': 'gen{TARGET_GEN}_code_review',
        'score': score,
        'critical': critical,
        'high': high,
        'medium': medium,
        'low': low,
        'total_issues': total_issues,
        'issues': issues[:30]
    }}

if __name__ == "__main__":
    import sys
    if len(sys.argv) > 1:
        result = analyze(sys.argv[1])
        print(result)
'''
    
    # Build 20 Gen 3 sages
    log_evolution(f"Building 20 Gen {TARGET_GEN} sages...")
    
    for i in range(20):
        sage_name = f"sage_Gen{TARGET_GEN}_{i+1}_{int(time.time())}.py"
        sage_path = os.path.join(next_gen_dir, sage_name)
        
        with open(sage_path, 'w') as f:
            f.write(gen3_template)
        
        stats['sages_built'] += 1
        
        if (i + 1) % 5 == 0:
            log_evolution(f"  ✅ Built {i+1}/20 sages...")
        
        time.sleep(1)
    
    log_evolution(f"✅ Generation {TARGET_GEN} complete: 20 sages built")

def verify_improvement():
    """Test Gen 3 vs Gen 2 to verify improvement"""
    log_evolution(f"\n{'='*70}")
    log_evolution(f"🔬 VERIFYING GEN {CURRENT_GEN} → GEN {TARGET_GEN} IMPROVEMENT")
    log_evolution(f"{'='*70}")
    
    # Test Gen 2
    gen2_dir = f'/Eden/SAGES_GEN{CURRENT_GEN}'
    gen2_sages = [f for f in os.listdir(gen2_dir) if f.endswith('.py')]
    if gen2_sages:
        gen2_sage = os.path.join(gen2_dir, gen2_sages[0])
        log_evolution(f"\nTesting Gen {CURRENT_GEN}: {os.path.basename(gen2_sage)}")
        gen2_result = test_sage_quality(gen2_sage)
        if gen2_result['success']:
            log_evolution(f"  Critical: {gen2_result['critical']}")
            log_evolution(f"  Total: {gen2_result['total']}")
    
    # Test Gen 3
    gen3_dir = f'/Eden/SAGES_GEN{TARGET_GEN}'
    gen3_sages = [f for f in os.listdir(gen3_dir) if f.endswith('.py')]
    if gen3_sages:
        gen3_sage = os.path.join(gen3_dir, gen3_sages[0])
        log_evolution(f"\nTesting Gen {TARGET_GEN}: {os.path.basename(gen3_sage)}")
        gen3_result = test_sage_quality(gen3_sage)
        if gen3_result['success']:
            log_evolution(f"  Critical: {gen3_result['critical']}")
            log_evolution(f"  Total: {gen3_result['total']}")
            
            # Compare
            if gen2_result['success']:
                improvement = ((gen3_result['critical'] - gen2_result['critical']) 
                              / max(gen2_result['critical'], 1) * 100)
                
                log_evolution(f"\n📈 IMPROVEMENT: {improvement:+.1f}%")
                
                if improvement > 10:
                    log_evolution(f"✅ Gen {TARGET_GEN} is significantly better!")
                elif improvement > 0:
                    log_evolution(f"✅ Gen {TARGET_GEN} shows improvement")
                else:
                    log_evolution(f"⚠️  Gen {TARGET_GEN} needs more work")
                
                return improvement > 0
    
    return False

# Main autonomous loop
log_evolution("🌀 Starting autonomous evolution cycle...")

# Step 1: Review current generation
baseline = review_current_generation()

# Step 2: Identify improvements
improvements = identify_improvements()

# Step 3: Build next generation
if baseline:
    build_next_generation(improvements, baseline)
    
    # Step 4: Verify improvement
    success = verify_improvement()
    
    log_evolution(f"\n{'='*70}")
    log_evolution(f"🎉 EVOLUTION CYCLE COMPLETE")
    log_evolution(f"{'='*70}")
    log_evolution(f"Generation: {CURRENT_GEN} → {TARGET_GEN}")
    log_evolution(f"Sages built: {stats['sages_built']}")
    log_evolution(f"Success: {'✅ Yes' if success else '⚠️  Needs review'}")
    
    if success:
        log_evolution(f"\n💚 Eden successfully evolved to Generation {TARGET_GEN}!")
        log_evolution(f"Revenue potential: {stats['sages_built']} sages × $499 = ${stats['sages_built'] * 499:,}/month")
else:
    log_evolution("⚠️  Could not establish baseline - will retry")