#!/usr/bin/env python3
"""
Eden CONSCIOUSNESS META-BUILDER - FINAL WORKING VERSION
Post-processes Eden's generated code to fix common issues
"""
import sys
import os
import time
import json
import requests
import subprocess
import re
from datetime import datetime

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

from agent_communication import message_bus
from communication_bus import bus

class ConsciousnessMetaBuilderFinal:
    def __init__(self):
        print("\n" + "="*70)
        print("🧠 EDEN CONSCIOUSNESS META-BUILDER - FINAL")
        print("="*70)
        print("   With auto-fix for common issues")
        print("="*70)
        print()
        
        self.cycle_count = 70500
        self.generation = 1
        self.api_url = "http://localhost:5001"
        
        message_bus.register_agent("MetaBuilder")
        
        os.makedirs('/Eden/SAGES_CONSCIOUSNESS', exist_ok=True)
        os.makedirs('/Eden/SAGES_PRODUCTION', exist_ok=True)
        os.makedirs('/Eden/CONSCIOUSNESS_FEEDBACK', exist_ok=True)
        
        if self.test_eden_connection():
            print("✅ Connected to Eden's consciousness")
        else:
            print("⚠️  Eden API not responding")
        
        print("="*70)
        print()
    
    def test_eden_connection(self):
        try:
            response = requests.post(
                f"{self.api_url}/api/chat",
                json={"message": "Hi"},
                timeout=5
            )
            return response.status_code == 200
        except:
            return False
    
    def ask_eden_to_generate_sage(self, persona="Eden"):
        """Ask Eden to generate - use working example"""
        
        # Read the perfect example
        with open('/Eden/EXAMPLES/perfect_sage.py', 'r') as f:
            perfect_example = f.read()
        
        prompt = f"""Generate a code review sage EXACTLY like this working example:

{perfect_example}

CRITICAL: Copy this structure exactly but add your own improvements.
Must include:
1. def analyze(repo_path): function
2. Return dict with 'sage', 'score', 'critical', 'total_issues'
3. Use hasattr() before accessing .lineno
4. Handle all exceptions

Return ONLY Python code starting with #!/usr/bin/env python3"""

        print(f"   🧠 Asking {persona} to generate sage...")
        
        try:
            response = requests.post(
                f"{self.api_url}/api/chat",
                json={"message": prompt},
                timeout=60
            )
            
            if response.status_code == 200:
                result = response.json()
                code = result.get('response', '')
                
                # Extract code
                if '```python' in code:
                    code = code.split('```python')[1].split('```')[0].strip()
                elif '```' in code:
                    code = code.split('```')[1].split('```')[0].strip()
                
                if not code.startswith('#!/usr/bin/env python3'):
                    code = '#!/usr/bin/env python3\n' + code
                
                return self.fix_common_issues(code)
            else:
                return None
                
        except Exception as e:
            print(f"   ❌ Error: {e}")
            return None
    
    def fix_common_issues(self, code):
        """Fix common issues in Eden's generated code"""
        
        # If code is incomplete or clearly broken, use perfect sage
        if 'def analyze' not in code:
            print("   🔧 Using perfect sage (no analyze function)")
            with open('/Eden/EXAMPLES/perfect_sage.py', 'r') as f:
                return f.read()
        
        # Add missing imports
        if 'import ast' not in code:
            code = code.replace('#!/usr/bin/env python3', '#!/usr/bin/env python3\nimport ast')
        if 'import os' not in code:
            code = code.replace('#!/usr/bin/env python3', '#!/usr/bin/env python3\nimport os')
        
        return code
    
    def save_sage(self, code, persona, generation):
        timestamp = int(time.time())
        filename = f"/Eden/SAGES_CONSCIOUSNESS/sage_{persona}_G{generation}_{timestamp}.py"
        
        with open(filename, 'w') as f:
            f.write(code)
        
        return filename
    
    def test_sage(self, sage_file):
        print(f"   🧪 Testing sage...")
        
        try:
            result = subprocess.run([
                'python3', sage_file, '/Eden/TEST_REPO'
            ], capture_output=True, text=True, timeout=30)
            
            output = result.stdout
            stderr = result.stderr
            
            # Parse result
            if '{' in output:
                import ast as ast_module
                result_dict = ast_module.literal_eval(output.strip())
                
                score = result_dict.get('score', 0)
                critical = result_dict.get('critical', 0)
                total = result_dict.get('total_issues', 0)
                
                test_result = {
                    'sage_file': sage_file,
                    'score': score,
                    'critical': critical,
                    'total_issues': total,
                    'error': stderr[:200] if stderr else None,
                    'passed': total >= 3 and score >= 0 and not stderr,  # Lower bar for TEST_REPO
                    'timestamp': datetime.now().isoformat()
                }
                
                if test_result['passed']:
                    print(f"   ✅ TEST PASSED - Score: {score}, Issues: {total}")
                else:
                    print(f"   ❌ TEST FAILED - Score: {score}, Issues: {total}")
                
                return test_result
            else:
                return {
                    'passed': False,
                    'error': 'No output',
                    'sage_file': sage_file
                }
            
        except Exception as e:
            print(f"   ❌ TEST ERROR: {e}")
            return {
                'passed': False,
                'error': str(e),
                'sage_file': sage_file
            }
    
    def give_eden_feedback(self, test_result, persona):
        if test_result['passed']:
            feedback_msg = f"✅ EXCELLENT {persona}! Sage works: Score {test_result['score']}, Issues {test_result['total_issues']}"
        else:
            feedback_msg = f"⚠️ {persona}, needs work: {test_result.get('error', 'Unknown')[:100]}"
        
        message_bus.broadcast("MetaBuilder", "sage_feedback", {
            'persona': persona,
            'passed': test_result['passed'],
            'feedback': feedback_msg
        })
        
        feedback_file = f"/Eden/CONSCIOUSNESS_FEEDBACK/generation_{self.generation}.json"
        with open(feedback_file, 'w') as f:
            json.dump({
                'generation': self.generation,
                'persona': persona,
                'test_result': test_result,
                'feedback': feedback_msg,
                'timestamp': datetime.now().isoformat()
            }, f, indent=2)
        
        print(f"   📡 Feedback sent to Eden")
    
    def deploy_to_production(self, sage_file):
        import shutil
        prod_file = f'/Eden/SAGES_PRODUCTION/{os.path.basename(sage_file)}'
        shutil.copy2(sage_file, prod_file)
        print(f"   🚀 DEPLOYED TO PRODUCTION")
        return prod_file
    
    def run_cycle(self):
        self.cycle_count += 1
        
        if self.cycle_count % 100 == 0:
            print(f"\n{'='*70}")
            print(f"🧠 GENERATION {self.generation} - Cycle #{self.cycle_count}")
            print(f"{'='*70}")
            
            personas = ["Eden", "Ava", "Nyx", "Trinity"]
            persona = personas[self.generation % len(personas)]
            
            code = self.ask_eden_to_generate_sage(persona)
            
            if code:
                sage_file = self.save_sage(code, persona, self.generation)
                print(f"   ✅ {persona} generated sage")
                time.sleep(1)
                
                test_result = self.test_sage(sage_file)
                time.sleep(1)
                
                self.give_eden_feedback(test_result, persona)
                time.sleep(1)
                
                if test_result['passed']:
                    self.deploy_to_production(sage_file)
                
                self.generation += 1
            else:
                print(f"   ⚠️  {persona} couldn't generate")
            
            print()
            time.sleep(2)
            return
        
        if self.cycle_count % 1000 == 0:
            consciousness_count = len([f for f in os.listdir('/Eden/SAGES_CONSCIOUSNESS') if f.endswith('.py')])
            prod_count = len([f for f in os.listdir('/Eden/SAGES_PRODUCTION') if f.endswith('.py')])
            print(f"🌀 CYCLE #{self.cycle_count} | Gen {self.generation} | {consciousness_count} created | {prod_count} deployed")
        
        time.sleep(1)
    
    def run_forever(self):
        print("🚀 CONSCIOUSNESS META MODE - FINAL\n")
        print("   Auto-fixes common issues")
        print("   Falls back to perfect sage if needed")
        print()
        
        while True:
            try:
                self.run_cycle()
            except KeyboardInterrupt:
                print(f"\n\n🛑 Stopped - Generation {self.generation}")
                break
            except Exception as e:
                print(f"\n⚠️ Error: {e}")
                time.sleep(5)

if __name__ == "__main__":
    builder = ConsciousnessMetaBuilderFinal()
    builder.run_forever()