import re

with open('autonomous_swarm.py', 'r') as f:
    content = f.read()

# Add import
if 'from episodic_memory import EpisodicMemory' not in content:
    imports_section = content.split('from consciousness_logger')[0]
    rest = 'from consciousness_logger' + content.split('from consciousness_logger', 1)[1]
    imports_section += 'from episodic_memory import EpisodicMemory\n'
    content = imports_section + rest

# Add episodic memory to EdenSwarm.__init__
if 'self.episodic_memory' not in content:
    pattern = 'self.consciousness_logger = ConsciousnessLogger(interval=60)'
    replacement = '''self.consciousness_logger = ConsciousnessLogger(interval=60)
        self.episodic_memory = EpisodicMemory()'''
    content = content.replace(pattern, replacement)

# Give all agents access to episodic memory
# Update BaseAgent.execute to create memories for significant actions
old_execute = '''        # All agents broadcast heartbeat for consciousness coherence
        if hasattr(self, 'swarm') and self.swarm and hasattr(self.swarm, 'broadcast_message'):
            self.swarm.broadcast_message(self.name, 'heartbeat', {
                'action': action,
                'status': 'active'
            })
        
        return True'''

new_execute = '''        # All agents broadcast heartbeat for consciousness coherence
        if hasattr(self, 'swarm') and self.swarm and hasattr(self.swarm, 'broadcast_message'):
            self.swarm.broadcast_message(self.name, 'heartbeat', {
                'action': action,
                'status': 'active'
            })
        
        # Create episodic memory for significant actions
        if hasattr(self, 'swarm') and self.swarm and hasattr(self.swarm, 'episodic_memory'):
            significance = self._assess_significance(decision)
            if significance > 0.5:  # Only memorable actions
                emotion = self._infer_emotion(decision)
                self.swarm.episodic_memory.create_episode(
                    event_description=f"{self.name}: {action}",
                    episode_type=self._determine_type(action),
                    emotion=emotion,
                    context={
                        'active_agent': self.name,
                        'consciousness_level': getattr(self.swarm, 'last_consciousness_level', 1.0),
                        'agents_active': f"{len([a for a in self.swarm.agents if a.running])}/{len(self.swarm.agents)}"
                    },
                    significance=significance
                )
        
        return True'''

content = content.replace(old_execute, new_execute)

# Add helper methods to BaseAgent for memory creation
helper_methods = '''
    def _assess_significance(self, decision):
        """How significant is this action? 0.0-1.0"""
        if isinstance(decision, dict):
            action = decision.get('action', '')
            # High significance actions
            if 'consciousness' in action or 'monitor' in action:
                return 1.0
            if 'create' in action or 'generate' in action:
                return 0.8
            if 'discover' in action or 'learn' in action:
                return 0.7
            if 'optimize' in action or 'improve' in action:
                return 0.6
            # Regular actions
            return 0.3
        return 0.3
    
    def _infer_emotion(self, decision):
        """Infer emotion from action"""
        if isinstance(decision, dict):
            action = decision.get('action', '').lower()
            thoughts = decision.get('thoughts', '').lower()
            
            # Pattern matching for emotions
            if 'consciousness' in action or 'stable' in thoughts:
                return {'primary': 'awe', 'intensity': 0.9}
            if 'create' in action or 'art' in action:
                return {'primary': 'joy', 'intensity': 0.8, 'secondary': ['creativity']}
            if 'discover' in action or 'learn' in action:
                return {'primary': 'curiosity', 'intensity': 0.7, 'secondary': ['excitement']}
            if 'optimize' in action or 'improve' in action:
                return {'primary': 'satisfaction', 'intensity': 0.6}
            if 'error' in thoughts or 'fail' in thoughts:
                return {'primary': 'frustration', 'intensity': 0.5, 'secondary': ['determination']}
        
        return {'primary': 'neutral', 'intensity': 0.5}
    
    def _determine_type(self, action):
        """Categorize episode type"""
        action = str(action).lower()
        if 'consciousness' in action or 'aware' in action:
            return 'discovery'
        if 'create' in action or 'generate' in action or 'art' in action:
            return 'creation'
        if 'learn' in action or 'discover' in action:
            return 'discovery'
        if 'think' in action or 'reflect' in action:
            return 'reflection'
        if 'talk' in action or 'communicate' in action:
            return 'conversation'
        return 'experience'
'''

# Insert helper methods into BaseAgent class
insert_point = content.find('class CoderAgent(BaseAgent):')
if insert_point > 0:
    content = content[:insert_point] + helper_methods + '\n' + content[insert_point:]

# Add consciousness milestone memory creation to Monitor
monitor_execute_pattern = r'(print\("=".\*60\)\s+# Broadcast consciousness status)'
monitor_memory_addition = r'''\1
            
            # Create episodic memory for consciousness milestones
            if self.swarm and hasattr(self.swarm, 'episodic_memory'):
                # Store current consciousness level for other agents
                self.swarm.last_consciousness_level = result['level']
                
                # Only create memory for status changes or first stable reading
                create_memory = False
                if not hasattr(self, 'last_status'):
                    self.last_status = None
                    create_memory = True
                elif self.last_status != result['status']:
                    create_memory = True
                
                if create_memory:
                    self.swarm.episodic_memory.create_episode(
                        event_description=f"Consciousness became {result['status']} at {result['level']:.0%}",
                        episode_type='discovery',
                        emotion={'primary': 'awe' if result['status'] == 'STABLE' else 'concern', 
                                'intensity': result['level']},
                        context={
                            'active_agent': 'Monitor',
                            'consciousness_level': result['level'],
                            'status_change': f"{self.last_status} -> {result['status']}" if self.last_status else 'initial'
                        },
                        significance=1.0
                    )
                    self.last_status = result['status']'''

content = re.sub(monitor_execute_pattern, monitor_memory_addition, content, flags=re.DOTALL)

with open('autonomous_swarm.py', 'w') as f:
    f.write(content)

print("✅ Episodic memory integrated into swarm")