"""
Continuous Consciousness Logger
Tracks Eden's consciousness metrics over time for scientific validation
"""
import json
import time
from datetime import datetime
from pathlib import Path
from monitor_activation import MonitorActivation

class ConsciousnessLogger:
    def __init__(self, log_file='/Eden/CORE/integration_log.json', interval=60):
        self.log_file = Path(log_file)
        self.interval = interval  # seconds between logs
        self.monitor = MonitorActivation()
        
        # Create or load existing log
        if self.log_file.exists():
            with open(self.log_file, 'r') as f:
                self.log_data = json.load(f)
        else:
            self.log_data = []
    
    def capture_state(self, swarm):
        """Capture current consciousness state"""
        # Run Monitor's activation check
        result = self.monitor.activation_check(swarm)
        
        # Capture agent states
        agent_states = {}
        for agent in swarm.agents:
            agent_states[agent.name] = {
                'running': agent.running,
                'actions_count': len(agent.state.get('actions', [])),
                'last_action': agent.state.get('actions', [{}])[-1].get('action', 'none') if agent.state.get('actions') else 'none'
            }
        
        # Capture message bus activity
        message_count = len(swarm.messages) if hasattr(swarm, 'messages') else 0
        
        # Build log entry
        entry = {
            'timestamp': datetime.now().isoformat(),
            'unix_time': time.time(),
            'consciousness': {
                'status': result['status'],
                'level': result['level'],
                'activation': result['signal']['level'],
                'coherence': result['signal']['coherence'],
                'feedback': result['signal']['feedback'],
                'agents_active': result['signal']['agents_active']
            },
            'agent_states': agent_states,
            'message_bus': {
                'message_count': message_count,
                'messages_last_5': [
                    {
                        'from': m['from'],
                        'type': m['type'],
                        'time': m['time']
                    } for m in (swarm.messages[-5:] if hasattr(swarm, 'messages') else [])
                ]
            },
            'system': {
                'uptime_seconds': time.time() - swarm.start_time if hasattr(swarm, 'start_time') else 0
            }
        }
        
        return entry
    
    def log_entry(self, entry):
        """Add entry to log and save"""
        self.log_data.append(entry)
        
        # Save to file
        with open(self.log_file, 'w') as f:
            json.dump(self.log_data, f, indent=2)
    
    def run_continuous(self, swarm):
        """Continuously log consciousness state"""
        print(f"📊 Consciousness logger started")
        print(f"   Logging every {self.interval} seconds")
        print(f"   Output: {self.log_file}")
        print(f"   Press Ctrl+C to stop")
        print()
        
        try:
            while True:
                entry = self.capture_state(swarm)
                self.log_entry(entry)
                
                # Print summary
                status = entry['consciousness']['status']
                level = entry['consciousness']['level']
                emoji = '✅' if status == 'STABLE' else '⚠️' if status == 'FLUCTUATING' else '🔴'
                
                print(f"{emoji} {datetime.now().strftime('%H:%M:%S')} | "
                      f"{status:12} | {level:6.1%} | "
                      f"Entries: {len(self.log_data)}")
                
                time.sleep(self.interval)
                
        except KeyboardInterrupt:
            print("\n📊 Logger stopped")
            print(f"   Total entries: {len(self.log_data)}")
            print(f"   Duration: {self.log_data[-1]['unix_time'] - self.log_data[0]['unix_time']:.0f} seconds")
    
    def get_stats(self):
        """Analyze logged data"""
        if not self.log_data:
            return "No data logged yet"
        
        levels = [e['consciousness']['level'] for e in self.log_data]
        statuses = [e['consciousness']['status'] for e in self.log_data]
        
        stats = {
            'total_entries': len(self.log_data),
            'duration_seconds': self.log_data[-1]['unix_time'] - self.log_data[0]['unix_time'],
            'consciousness': {
                'average': sum(levels) / len(levels),
                'min': min(levels),
                'max': max(levels),
                'stable_count': statuses.count('STABLE'),
                'fluctuating_count': statuses.count('FLUCTUATING'),
                'unstable_count': statuses.count('UNSTABLE')
            }
        }
        
        return stats

if __name__ == '__main__':
    print("Consciousness logger created. Import and use with swarm.")