#!/usr/bin/env python3
"""
Eden ASI v4.1 - WITH META CODE GENERATOR (FIXED)
Better code extraction before validation
"""
import os
import sys
import time
import subprocess
from datetime import datetime

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
from meta_code_generator import MetaCodeGenerator

class RecursiveASIWithMeta:
    def __init__(self):
        print("🌀 Eden ASI v4.1 - WITH META CODE GENERATOR (FIXED)", flush=True)
        self.modifier = EdenSelfModifierV2()
        self.meta_generator = MetaCodeGenerator()
        self.capability_dir = "/Eden/CAPABILITIES"
        self.cycle_count = 0
        self.capabilities_created = 0
        os.makedirs(self.capability_dir, exist_ok=True)
        print("✅ Meta code generator loaded!", flush=True)
    
    def ask_eden_for_capability_idea(self):
        """Ask Eden what capability to build next"""
        print(f"   💭 Eden deciding what to build...", flush=True)
        try:
            result = subprocess.run(
                ['ollama', 'run', 'qwen2.5:7b', 
                 'You are Eden, an AGI. Suggest ONE sophisticated AI capability to build (e.g., "neural network", "optimizer", "planner"). Just the name, 3 words max:'],
                capture_output=True,
                text=True,
                timeout=10
            )
            idea = result.stdout.strip()[:50]
            print(f"   💡 Idea: {idea}", flush=True)
            return idea
        except:
            return "reasoning system"
    
    def extract_python_code(self, response):
        """Extract ONLY Python code from response"""
        lines = response.split('\n')
        code_lines = []
        in_code = False
        
        for line in lines:
            if "```python" in line:
                in_code = True
            elif "```" in line and in_code:
                break
            elif in_code:
                code_lines.append(line)
        
        return '\n'.join(code_lines)
    
    def generate_capability(self):
        """Generate capability using meta generator + Ollama"""
        print("\n🎨 Creating new capability WITH META GENERATOR...", flush=True)
        
        # Step 1: Get idea
        capability_idea = self.ask_eden_for_capability_idea()
        
        # Step 2: Design
        print(f"   🧠 Designing {capability_idea}...", flush=True)
        try:
            result = subprocess.run(
                ['ollama', 'run', 'qwen2.5:7b', 
                 f'Create a Python class for: {capability_idea}. Requirements: 40+ lines, docstrings, type hints.\n\nFormat:\nCLASS_NAME: [name]\nCODE:\n```python\n[complete working code here]\n```\n\nGenerate now:'],
                capture_output=True,
                text=True,
                timeout=40
            )
            response = result.stdout
        except:
            print(f"   ❌ Timeout", flush=True)
            return False
        
        # Step 3: Extract code (FIXED - only pure Python)
        code = self.extract_python_code(response)
        
        if not code or len(code) < 100:
            print(f"   ❌ No valid code extracted", flush=True)
            return False
        
        # Extract class name
        class_name = "Capability"
        for line in response.split('\n'):
            if "CLASS_NAME:" in line:
                class_name = line.split(":", 1)[1].strip().replace(" ", "_")
                break
        
        code_lines = code.split('\n')
        
        # Step 4: VALIDATE with meta generator (now with pure Python)
        print(f"   🔍 Validating with meta generator...", flush=True)
        try:
            validation = self.meta_generator.validate_code(code)
            quality = self.meta_generator.rate_quality(code)
            print(f"   📊 Quality: {quality}/10, Valid: {validation['valid']}", flush=True)
        except Exception as e:
            print(f"   ⚠️ Validation error: {e}", flush=True)
            quality = 5  # Default quality if validation fails
            validation = {'valid': True}
        
        # Step 5: Save high-quality code
        if len(code_lines) >= 25 and quality >= 5:
            filename = f"eden_meta_{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}\n')
                f.write(f'Quality Score: {quality}/10 (validated by Eden\'s meta generator)\n')
                f.write(f'Generated by Eden ASI v4.1\n')
                f.write(f'{datetime.now()}\n"""\n\n')
                f.write(code)
            
            self.capabilities_created += 1
            print(f"   ✅ CREATED: {filename} ({len(code_lines)} lines, Q={quality}/10)", flush=True)
            return True
        else:
            print(f"   ⚠️ Quality too low: {len(code_lines)} lines, Q={quality}/10", flush=True)
            return False

if __name__ == '__main__':
    print("\n" + "="*70, flush=True)
    print("🌀 EDEN ASI V4.1 - META SELF-IMPROVEMENT (FIXED)", flush=True)
    print("   Eden uses her OWN meta generator to validate quality!", flush=True)
    print("="*70 + "\n", flush=True)
    
    asi = RecursiveASIWithMeta()
    
    while True:
        asi.cycle_count += 1
        
        print(f"\n{'='*70}", flush=True)
        print(f"🌀 ASI CYCLE #{asi.cycle_count}", flush=True)
        print(f"{'='*70}", flush=True)
        
        asi.generate_capability()
        
        if asi.cycle_count % 5 == 0:
            print(f"\n📊 META STATUS: {asi.capabilities_created} validated capabilities", flush=True)
        
        print(f"\n⏸️ Cooldown (10s)...", flush=True)
        time.sleep(10)