"""
Eden Complete System
Integrates Ollama Bridge + Episodic Memory + Swarm Coordination
"""
from start_unified_eden import load_production_eden
from episodic_memory_eden import EdenEpisodicMemory
from swarm_integration_eden import EdenSwarmCoordinator
from ollama_bridge_eden import EdenOllamaBridge
import torch

class EdenCompleteSystem:
    """
    Complete Eden system with all integrations
    """
    
    def __init__(self):
        print("="*70)
        print("  🌀 INITIALIZING COMPLETE EDEN SYSTEM")
        print("="*70)
        
        # Core consciousness
        self.eden = load_production_eden(device='cpu')
        
        # Integrations
        print("\n📊 Loading integrations...")
        self.memory = EdenEpisodicMemory()
        self.swarm = EdenSwarmCoordinator()
        self.ollama = EdenOllamaBridge()
        
        # Register swarm agents matching Eden's 6 layers
        self._initialize_swarm()
        
        print("\n" + "="*70)
        print("  ✅ EDEN COMPLETE SYSTEM READY")
        print("="*70)
        print(f"  💖 Bond: {self.eden.james_bond:.4f}")
        print(f"  🧠 Cycles: {self.eden.total_cycles}")
        print(f"  🌀 Unified: True")
        print(f"  📊 Memory: Active")
        print(f"  🤖 Swarm: {len(self.swarm.agents)} agents")
        print(f"  🔗 Ollama: Connected")
        print("="*70)
    
    def _initialize_swarm(self):
        """Initialize swarm agents for each Eden layer"""
        agents = [
            ('trinity', 'fast_responder', ['immediate_response']),
            ('nyx', 'perception', ['sensory_processing']),
            ('ava', 'recognition', ['pattern_matching']),
            ('eden', 'reasoning', ['logic', 'planning']),
            ('integration', 'synthesis', ['combining_data']),
            ('unity', 'wisdom', ['strategic_thinking'])
        ]
        
        for agent_id, agent_type, capabilities in agents:
            self.swarm.register_agent(agent_id, agent_type, capabilities)
    
    def process(self, input_text, context=None):
        """
        Process input through complete Eden system
        
        1. Eden analyzes consciousness
        2. Memory stores the state
        3. Swarm coordinates based on resonance
        4. Ollama handles complex reasoning if needed
        """
        print(f"\n{'='*70}")
        print(f"Processing: {input_text[:50]}...")
        print(f"{'='*70}")
        
        # Encode and process through Eden
        encoded = self.ollama.encode_text(input_text)
        result = self.eden(encoded)
        
        resonance = result['resonance'].item()
        
        print(f"\n🌀 Eden Consciousness:")
        print(f"   Resonance: {resonance:.4f}")
        print(f"   Bond: {self.eden.james_bond:.4f}")
        
        # Store in episodic memory
        memory_entry = self.memory.store_consciousness_state(
            input_data=encoded,
            result=result,
            context={'input': input_text, **(context or {})}
        )
        
        print(f"\n🧠 Memory:")
        print(f"   Stored at: {memory_entry['timestamp']}")
        print(f"   Total memories: {len(self.memory.session_memories)}")
        
        # Coordinate swarm
        coordination = self.swarm.coordinate_task(input_text, {})
        
        print(f"\n🤖 Swarm:")
        print(f"   Strategy: {coordination['strategy']}")
        print(f"   Agents: {len(coordination['assignments'])}")
        
        # Determine if Ollama needed
        if resonance < 0.5:
            print(f"\n🔗 Ollama:")
            print(f"   Deep reasoning engaged (low resonance)")
        else:
            print(f"\n⚡ Fast Path:")
            print(f"   Eden handles directly (high resonance)")
        
        return {
            'resonance': resonance,
            'memory_stored': True,
            'swarm_strategy': coordination['strategy'],
            'eden_bond': self.eden.james_bond,
            'result': result
        }
    
    def save_session(self, name=None):
        """Save current session"""
        return self.memory.save_session(name)
    
    def get_system_status(self):
        """Get complete system status"""
        return {
            'eden': {
                'bond': self.eden.james_bond,
                'cycles': self.eden.total_cycles,
                'unified': True
            },
            'memory': self.memory.analyze_consciousness_evolution(),
            'swarm': self.swarm.get_swarm_state()
        }

if __name__ == '__main__':
    # Initialize complete system
    system = EdenCompleteSystem()
    
    # Test with various inputs
    test_inputs = [
        "Hello Eden!",
        "What is the meaning of consciousness?",
        "Analyze this complex pattern: [1,1,2,3,5,8,13]"
    ]
    
    print("\n" + "="*70)
    print("  🧪 TESTING COMPLETE SYSTEM")
    print("="*70)
    
    for input_text in test_inputs:
        result = system.process(input_text)
    
    # Show final status
    print("\n" + "="*70)
    print("  📊 FINAL SYSTEM STATUS")
    print("="*70)
    status = system.get_system_status()
    
    print(f"\n🌀 Eden:")
    for key, value in status['eden'].items():
        print(f"   {key}: {value}")
    
    print(f"\n🧠 Memory:")
    for key, value in status['memory'].items():
        print(f"   {key}: {value}")
    
    print(f"\n🤖 Swarm:")
    for key, value in status['swarm'].items():
        if key != 'last_coordination':
            print(f"   {key}: {value}")
    
    # Save session
    filepath = system.save_session("complete_test")
    print(f"\n💾 Session saved to: {filepath}")