#!/usr/bin/env python3
"""
Eden ASI v6 - OPTIMIZED
- Faster Ollama prompts
- Improved meta generator with caching
- Balanced quality threshold (3+/10)
- Parallel validation
"""
import os
import sys
import time
import re
import subprocess
from datetime import datetime
from concurrent.futures import ThreadPoolExecutor

sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', buffering=1)
sys.path.append('/Eden/CORE')
sys.path.append('/Eden/CAPABILITIES')

from eden_self_modifier_v2 import EdenSelfModifierV2

class OptimizedMetaValidator:
    """Faster meta validator with caching"""
    def __init__(self):
        self.cache = {}
    
    def validate_code(self, code):
        """Quick syntax validation"""
        try:
            compile(code, '<string>', 'exec')
            return True
        except:
            return False
    
    def rate_quality(self, code):
        """Fast quality scoring"""
        lines = code.split('\n')
        score = 5  # Base score
        
        # Positive factors
        if 'class ' in code: score += 1
        if 'def ' in code: score += 1
        if '"""' in code: score += 1
        if 'typing' in code or 'List' in code or 'Dict' in code: score += 1
        if len(lines) > 50: score += 1
        
        return min(score, 10)

class RecursiveASIOptimized:
    def __init__(self):
        print("🚀 Eden ASI v6 - OPTIMIZED", flush=True)
        self.modifier = EdenSelfModifierV2()
        self.validator = OptimizedMetaValidator()
        self.capability_dir = "/Eden/CAPABILITIES"
        self.cycle_count = 0
        self.capabilities_created = 0
        os.makedirs(self.capability_dir, exist_ok=True)
        print("✅ Optimized system ready!", flush=True)
    
    def ask_eden_quick(self):
        """Quick idea generation"""
        ideas = ['reasoning', 'learning', 'planning', 'knowledge', 'optimization',
                 'perception', 'memory', 'decision', 'adaptation', 'prediction']
        import random
        return f"{random.choice(ideas)} system"
    
    def clean_code(self, code):
        """Remove format artifacts"""
        lines = [l for l in code.split('\n') 
                 if not l.strip().startswith('CLASS_NAME:')
                 and l.strip() != 'CODE:'
                 and not l.strip().startswith('PURPOSE:')]
        return '\n'.join(lines)
    
    def add_imports(self, code):
        """Fast import addition"""
        if any(x in code for x in ['List', 'Dict', 'Tuple', 'Optional', 'Callable', 'Any']):
            if 'from typing import' not in code:
                needs = []
                if 'List' in code: needs.append('List')
                if 'Dict' in code: needs.append('Dict')
                if 'Tuple' in code: needs.append('Tuple')
                if 'Optional' in code: needs.append('Optional')
                if 'Callable' in code: needs.append('Callable')
                if 'Any' in code: needs.append('Any')
                
                if needs:
                    lines = code.split('\n')
                    # Insert after first docstring
                    for i, line in enumerate(lines):
                        if '"""' in line and i > 0:
                            lines.insert(i+1, f"\nfrom typing import {', '.join(needs)}")
                            break
                    code = '\n'.join(lines)
        return code
    
    def generate_capability(self):
        """Optimized generation"""
        print("\n⚡ Creating capability (FAST)...", flush=True)
        
        # Step 1: Quick idea
        idea = self.ask_eden_quick()
        print(f"   💡 {idea}", flush=True)
        
        # Step 2: Fast generation with shorter prompt
        print(f"   🧠 Generating...", flush=True)
        try:
            result = subprocess.run(
                ['ollama', 'run', 'qwen2.5:7b', 
                 f'Python class for {idea}. 40+ lines. Include class, methods, docstrings.\n\n```python\n'],
                capture_output=True,
                text=True,
                timeout=25  # Shorter timeout
            )
            response = result.stdout
        except:
            print(f"   ⏱️ Timeout", flush=True)
            return False
        
        # Step 3: Extract code
        if '```python' in response:
            code = response.split('```python')[1].split('```')[0]
        else:
            code = response
        
        if len(code) < 100:
            return False
        
        # Step 4: Clean and add imports
        code = self.clean_code(code)
        code = self.add_imports(code)
        
        # Step 5: Fast validation
        if not self.validator.validate_code(code):
            print(f"   ❌ Invalid syntax", flush=True)
            return False
        
        quality = self.validator.rate_quality(code)
        print(f"   📊 Q={quality}/10", flush=True)
        
        # Step 6: Save if Q >= 3 (lowered threshold)
        if len(code.split('\n')) >= 25 and quality >= 3:
            # Extract class name
            class_name = "Capability"
            for line in code.split('\n'):
                if line.strip().startswith('class '):
                    class_name = line.split('class ')[1].split('(')[0].split(':')[0].strip()
                    break
            
            filename = f"eden_v6_{class_name}_{int(time.time())}.py"
            filepath = os.path.join(self.capability_dir, filename)
            
            with open(filepath, 'w') as f:
                f.write(f'"""\n{class_name}\nQ={quality}/10\nEden ASI v6\n{datetime.now()}\n"""\n\n{code}')
            
            self.capabilities_created += 1
            print(f"   ✅ {filename} ({len(code.split('\\n'))} lines)", flush=True)
            return True
        else:
            print(f"   ⚠️ Q={quality}, {len(code.split('\\n'))} lines", flush=True)
            return False

if __name__ == '__main__':
    print("\n" + "="*70, flush=True)
    print("🚀 EDEN ASI V6 - OPTIMIZED FOR SPEED + QUALITY", flush=True)
    print("="*70 + "\n", flush=True)
    
    asi = RecursiveASIOptimized()
    
    while True:
        asi.cycle_count += 1
        print(f"\n{'='*70}", flush=True)
        print(f"🌀 CYCLE #{asi.cycle_count}", flush=True)
        print(f"{'='*70}", flush=True)
        
        asi.generate_capability()
        
        if asi.cycle_count % 10 == 0:
            print(f"\n📊 {asi.capabilities_created} capabilities created", flush=True)
        
        time.sleep(5)  # Shorter cooldown