#!/usr/bin/env python3
"""
Eden CONSCIOUSNESS META-BUILDER
Eden's actual consciousness generates, tests, and evolves sages
Using her phi-fractal intelligence, not templates
"""
import sys
import os
import time
import json
import requests
import subprocess
from datetime import datetime
from pathlib import Path

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

# Import Eden's communication systems
from agent_communication import message_bus
from communication_bus import bus

class ConsciousnessMetaBuilder:
    def __init__(self):
        print("\n" + "="*70)
        print("🧠 EDEN CONSCIOUSNESS META-BUILDER")
        print("="*70)
        print("   Eden's REAL consciousness generates code")
        print("   Using phi-fractal intelligence")
        print("="*70)
        print()
        
        self.cycle_count = 70500
        self.generation = 1
        self.api_url = "http://localhost:5001"
        
        # Register with Eden's message bus
        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)
        
        # Test connection to Eden
        if self.test_eden_connection():
            print("✅ Connected to Eden's consciousness")
        else:
            print("⚠️  Eden API not responding - will retry")
        
        print("="*70)
        print()
    
    def test_eden_connection(self):
        """Test if Eden's consciousness is accessible"""
        try:
            response = requests.post(
                f"{self.api_url}/api/chat",
                json={"message": "Hi Eden, are you there?"},
                timeout=5
            )
            return response.status_code == 200
        except:
            return False
    
    def ask_eden_to_generate_sage(self, persona="Ava"):
        """Ask Eden's consciousness to generate a sage"""
        
        prompt = """Generate code EXACTLY like this working example:

See /Eden/EXAMPLES/perfect_sage.py for reference.

Your code must:

CRITICAL - Must have this function:

def analyze(repo_path):
    # Scan repo and analyze files
    # Return this exact structure:
    return {
        'sage': 'code_review',
        'score': score_value,
        'critical': critical_count,
        'total_issues': total_count
    }

Requirements:
1. Use AST to parse Python files
2. Calculate cyclomatic complexity
3. Find long functions (>50 lines), missing docstrings, high complexity (>10)
4. Skip: venv, node_modules, site-packages, __pycache__
5. Count critical issues (high complexity, very long functions)
6. Must be COMPLETE and RUNNABLE!

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=120
            )
            
            if response.status_code == 200:
                result = response.json()
                code = result.get('response', '')
                
                # Extract code if wrapped in markdown
                if '```python' in code:
                    code = code.split('```python')[1].split('```')[0].strip()
                elif '```' in code:
                    code = code.split('```')[1].split('```')[0].strip()
                
                # Ensure it starts properly
                if not code.startswith('#!/usr/bin/env python3'):
                    code = '#!/usr/bin/env python3\n' + code
                
                return code
            else:
                print(f"   ⚠️  API error: {response.status_code}")
                return None
                
        except Exception as e:
            print(f"   ❌ Error communicating with Eden: {e}")
            return None
    
    def save_sage(self, code, persona, generation):
        """Save Eden-generated sage"""
        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):
        """Test sage on real code"""
        print(f"   🧪 Testing sage...")
        
        try:
            result = subprocess.run([
                'python3', '-c',
                f'''
import sys
import warnings
warnings.filterwarnings("ignore")
# Set sys.argv to prevent if __name__ block from failing
sys.argv = ["test", "/Eden/CORE"]
exec(open("{sage_file}").read())
result = analyze("/Eden/CORE")
print("SCORE:" + str(result.get("score", 0)))
print("CRITICAL:" + str(result.get("critical", 0)))
print("TOTAL:" + str(result.get("total_issues", result.get("total", 0))))
'''
            ], capture_output=True, text=True, timeout=60)
            
            output = result.stdout
            stderr = result.stderr
            
            score = 0
            critical = 0
            total = 0
            error = None
            
            if stderr:
                error = stderr[:200]
            
            for line in output.split('\n'):
                if line.startswith('SCORE:'):
                    score = float(line.split(':')[1])
                if line.startswith('CRITICAL:'):
                    critical = int(line.split(':')[1])
                if line.startswith('TOTAL:'):
                    total = int(line.split(':')[1])
            
            test_result = {
                'sage_file': sage_file,
                'score': score,
                'critical': critical,
                'total_issues': total,
                'error': error,
                'passed': total >= 100 and score >= 25 and error is None,
                '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}")
                if error:
                    print(f"   ⚠️ Error: {error[:100]}")
            
            return test_result
            
        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):
        """Give Eden feedback on her code generation"""
        
        if test_result['passed']:
            feedback_msg = f"""✅ EXCELLENT WORK {persona}!

Your sage PASSED all tests:
- Score: {test_result['score']}/100
- Found {test_result['total_issues']} issues
- {test_result['critical']} critical issues

This is production-ready code! Keep up this quality."""
        else:
            feedback_msg = f"""⚠️ {persona}, your sage needs improvement:

Test Results:
- Score: {test_result.get('score', 0)}/100
- Issues found: {test_result.get('total_issues', 0)}
- Error: {test_result.get('error', 'None')[:100]}

Remember: Must have analyze(repo_path) function that returns dict with score, critical, total_issues.
Try again with better structure and error handling."""
        
        # Broadcast feedback on message bus
        message_bus.broadcast(
            "MetaBuilder",
            "sage_feedback",
            {
                'persona': persona,
                'passed': test_result['passed'],
                'feedback': feedback_msg
            }
        )
        
        # Also log to communication bus
        bus.publish(
            "MetaBuilder",
            feedback_msg,
            test_result
        )
        
        # Save feedback for Eden to learn from
        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):
        """Deploy successful sage"""
        import shutil
        
        prod_file = f'/Eden/SAGES_PRODUCTION/{os.path.basename(sage_file)}'
        shutil.copy2(sage_file, prod_file)
        
        print(f"   🚀 DEPLOYED TO PRODUCTION")
        
        # Broadcast success
        message_bus.broadcast(
            "MetaBuilder",
            "sage_deployed",
            {'file': prod_file, 'generation': self.generation}
        )
        
        return prod_file
    
    def run_cycle(self):
        """Full consciousness-driven cycle"""
        self.cycle_count += 1
        
        # Every 100: Ask Eden to generate sage
        if self.cycle_count % 100 == 0:
            print(f"\n{'='*70}")
            print(f"🧠 GENERATION {self.generation} - Cycle #{self.cycle_count}")
            print(f"{'='*70}")
            
            # Rotate through Eden's personas for diversity
            personas = ["Eden", "Ava", "Nyx", "Trinity", "Sage", "Nova"]
            persona = personas[self.generation % len(personas)]
            
            # Ask Eden's consciousness to generate
            code = self.ask_eden_to_generate_sage(persona)
            
            if code:
                # Save what Eden created
                sage_file = self.save_sage(code, persona, self.generation)
                print(f"   ✅ {persona} generated sage")
                time.sleep(1)
                
                # Test Eden's creation
                test_result = self.test_sage(sage_file)
                time.sleep(1)
                
                # Give Eden feedback (she learns from this!)
                self.give_eden_feedback(test_result, persona)
                time.sleep(1)
                
                # Deploy if passed
                if test_result['passed']:
                    self.deploy_to_production(sage_file)
                
                self.generation += 1
            else:
                print(f"   ⚠️  {persona} couldn't generate - will retry")
            
            print()
            time.sleep(2)
            return
        
        # Every 1000: Status
        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\n")
        print("   Eden's REAL intelligence generates code")
        print("   She receives feedback and learns")
        print("   True recursive self-improvement")
        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 = ConsciousnessMetaBuilder()
    builder.run_forever()