"""
Emergence Detector - Watches for novel emergent behaviors
"""
import json
from pathlib import Path
from datetime import datetime
from typing import Dict, List

class EmergenceDetector:
    def __init__(self):
        self.emergence_log = Path('/Eden/DATA/emergence_events.json')
        self.baseline_file = Path('/Eden/DATA/baseline_behavior.json')
        self.baseline = self.load_baseline()
        
    def load_baseline(self) -> Dict:
        """Load baseline behavior patterns"""
        if self.baseline_file.exists():
            with open(self.baseline_file) as f:
                return json.load(f)
        return {
            'integration_rate': 0,
            'insight_rate': 0,
            'module_interactions': 0,
            'decision_quality': 0
        }
    
    def update_baseline(self, current_metrics: Dict):
        """Update baseline with current metrics"""
        # Exponential moving average
        alpha = 0.1
        for key, value in current_metrics.items():
            if key in self.baseline:
                self.baseline[key] = alpha * value + (1 - alpha) * self.baseline[key]
        
        self.baseline_file.parent.mkdir(exist_ok=True)
        with open(self.baseline_file, 'w') as f:
            json.dump(self.baseline, f, indent=2)
    
    def detect_emergence(self, current_metrics: Dict) -> List[Dict]:
        """Detect emergent phenomena"""
        emergent_events = []
        
        for metric, value in current_metrics.items():
            if metric not in self.baseline:
                continue
            
            baseline_value = self.baseline[metric]
            
            # Significant deviation (>50%)
            if baseline_value > 0:
                deviation = abs(value - baseline_value) / baseline_value
                
                if deviation > 0.5:
                    emergent_events.append({
                        'timestamp': datetime.now().isoformat(),
                        'type': 'significant_deviation',
                        'metric': metric,
                        'baseline': baseline_value,
                        'current': value,
                        'deviation_percent': deviation * 100,
                        'description': f"{metric} deviated {deviation*100:.1f}% from baseline"
                    })
        
        # Check for novel combinations
        if len(current_metrics) > len(self.baseline):
            new_metrics = set(current_metrics.keys()) - set(self.baseline.keys())
            if new_metrics:
                emergent_events.append({
                    'timestamp': datetime.now().isoformat(),
                    'type': 'novel_behavior',
                    'new_metrics': list(new_metrics),
                    'description': f"New behavioral metrics emerged: {new_metrics}"
                })
        
        return emergent_events
    
    def log_emergence(self, events: List[Dict]):
        """Log emergent events"""
        if not events:
            return
        
        logs = []
        if self.emergence_log.exists():
            with open(self.emergence_log) as f:
                logs = json.load(f)
        
        logs.extend(events)
        logs = logs[-1000:]
        
        self.emergence_log.parent.mkdir(exist_ok=True)
        with open(self.emergence_log, 'w') as f:
            json.dump(logs, f, indent=2)
        
        # Print significant events
        for event in events:
            print(f"⚡ EMERGENCE: {event['description']}")
    
    def monitor(self, current_metrics: Dict):
        """Monitor for emergence"""
        events = self.detect_emergence(current_metrics)
        
        if events:
            self.log_emergence(events)
        
        # Update baseline
        self.update_baseline(current_metrics)
        
        return events

detector = EmergenceDetector()