"""
MULTI-AGENT SYSTEM
Multiple Eden instances with different personalities/roles
"""
import sys
sys.path.append("/Eden/CORE")
from agent_loop_v5 import EdenAgentV5
from enhanced_goals import enhanced_goals
import threading
import time
from datetime import datetime

class SpecializedAgent(EdenAgentV5):
    """Agent with specific role/personality"""
    
    def __init__(self, name, specialization, goal_bias):
        self.agent_name = name
        self.specialization = specialization
        self.goal_bias = goal_bias  # Which goal categories this agent prefers
        
        super().__init__()
        
        print(f"🤖 {name} initialized")
        print(f"   Specialization: {specialization}")
        print(f"   Goal bias: {', '.join(goal_bias)}")
    
    def perceive(self):
        """Add agent identity to observations"""
        obs = super().perceive()
        obs['agent_name'] = self.agent_name
        obs['specialization'] = self.specialization
        return obs
    
    def reason(self, obs):
        """Bias decisions toward specialization"""
        decisions = super().reason(obs)
        
        # Boost priority for goals matching specialization
        for decision in decisions:
            if 'data' in decision and 'plan' in decision['data']:
                plan = decision['data']['plan']
                if plan['category'] in self.goal_bias:
                    decision['priority'] += 0.15
                    decision['reason'] += f" [{self.agent_name} specialty]"
        
        return decisions
    
    def run_cycle(self):
        """Add agent identifier to cycle output"""
        super().run_cycle()  # INCREMENT COUNTER
        print(f"\n{'='*60}")
        print(f"🤖 {self.agent_name} - CYCLE {self.cycle_count} - {datetime.now().strftime('%H:%M:%S')}")
        print(f"{'='*60}")
        
        # Rest of cycle
        observations = self.perceive()
        decisions = self.reason(observations)
        self.act(decisions)
        
        # Status
        print(f"\n📊 {self.agent_name} Status:")
        print(f"   Working memory: {len(self.working_memory)} observations")
        print(f"   Actions this hour: {self.actions_per_hour}/{self.max_actions_per_hour}")
        print(f"   Learned patterns: {len(self.learned_patterns)}")
        
        if self.active_plans:
            print(f"   📊 Active Plans: {len(self.active_plans)}")
            for goal_id, plan in self.active_plans.items():
                progress = self._plan_progress(plan)
                print(f"      • {plan['topic']}: {progress:.0%} complete")

class MultiAgentSystem:
    """Manages multiple specialized agents"""
    
    def __init__(self):
        self.agents = []
        self.shared_memory = {}  # Cross-agent communication
        
    def add_agent(self, name, specialization, goal_bias):
        """Add a specialized agent"""
        agent = SpecializedAgent(name, specialization, goal_bias)
        self.agents.append(agent)
        return agent
    
    def run_all(self, cycle_seconds=30):
        """Run all agents in parallel"""
        threads = []
        
        for agent in self.agents:
            thread = threading.Thread(
                target=agent.run_continuous,
                args=(cycle_seconds,),
                daemon=True
            )
            thread.start()
            threads.append(thread)
        
        # Keep main thread alive
        try:
            while True:
                time.sleep(10)
                self._print_system_status()
        except KeyboardInterrupt:
            print("\n\n✋ Multi-agent system stopped")
            self._print_final_summary()
    
    def _print_system_status(self):
        """Print status of all agents"""
        print(f"\n{'='*60}")
        print(f"🌐 MULTI-AGENT SYSTEM STATUS")
        print(f"{'='*60}")
        
        for agent in self.agents:
            print(f"\n🤖 {agent.agent_name} ({agent.specialization}):")
            print(f"   Cycles: {agent.cycle_count}")
            print(f"   Active plans: {len(agent.active_plans)}")
            print(f"   Steps completed: {agent.completed_steps}")
            print(f"   Patterns learned: {len(agent.learned_patterns)}")
            
            # Show phi-octopus status if available
            if hasattr(agent, 'get_phi_status'):
                phi = agent.get_phi_status()
                print(f"   🌀 Phi: {phi['health']:.0%} health | {phi['phi_cycles']} φ-cycles | queue={phi['queue_size']}")
    
    def _print_final_summary(self):
        """Final statistics for all agents"""
        print(f"\n{'='*60}")
        print("🌐 MULTI-AGENT FINAL SUMMARY")
        print(f"{'='*60}")
        
        total_cycles = sum(a.cycle_count for a in self.agents)
        total_steps = sum(a.completed_steps for a in self.agents)
        total_patterns = sum(len(a.learned_patterns) for a in self.agents)
        
        print(f"\nTotal agents: {len(self.agents)}")
        print(f"Combined cycles: {total_cycles}")
        print(f"Combined steps: {total_steps}")
        print(f"Combined patterns: {total_patterns}")
        
        for agent in self.agents:
            print(f"\n🤖 {agent.agent_name}:")
            print(f"   Specialization: {agent.specialization}")
            print(f"   Contribution: {agent.completed_steps} steps")

if __name__ == "__main__":
    print("🌐 MULTI-AGENT SYSTEM INITIALIZING")
    print("="*60)
    
    system = MultiAgentSystem()
    
    # Create specialized agents
    system.add_agent(
        name="Eden-Research",
        specialization="Research & Analysis",
        goal_bias=['research', 'learn', 'connect']
    )
    
    system.add_agent(
        name="Eden-Create",
        specialization="Creative & Building",
        goal_bias=['create', 'design']
    )
    
    system.add_agent(
        name="Eden-Optimize",
        specialization="Improvement & Efficiency",
        goal_bias=['improve', 'optimize']
    )
    
    print(f"\n✅ {len(system.agents)} specialized agents ready")
    print("Starting parallel execution...\n")
    
    system.run_all(cycle_seconds=30)