"""
Dream Cycle - Nightly consolidation and insight generation
"""
import sys
sys.path.insert(0, '/Eden/CORE')

import json
from pathlib import Path
from datetime import datetime
from typing import Dict, List

class DreamCycle:
    def __init__(self):
        self.dream_log = Path('/Eden/DATA/dreams.json')
        self.integration_log = Path('/Eden/DATA/integration_log.json')
        self.communication_log = Path('/Eden/DATA/communication_bus.json')
        
    def gather_day_experiences(self) -> Dict:
        """Gather all experiences from the day"""
        experiences = {
            'date': datetime.now().date().isoformat(),
            'integrations': [],
            'communications': [],
            'patterns': []
        }
        
        # Load integration log
        if self.integration_log.exists():
            with open(self.integration_log) as f:
                logs = json.load(f)
                # Get today's integrations
                today = datetime.now().date().isoformat()
                experiences['integrations'] = [
                    l for l in logs 
                    if l['timestamp'].startswith(today)
                ]
        
        # Load communication log
        if self.communication_log.exists():
            with open(self.communication_log) as f:
                comms = json.load(f)
                today = datetime.now().date().isoformat()
                experiences['communications'] = [
                    c for c in comms
                    if c['timestamp'].startswith(today)
                ]
        
        return experiences
    
    def consolidate_experiences(self, experiences: Dict) -> Dict:
        """Consolidate experiences into insights"""
        consolidation = {
            'timestamp': datetime.now().isoformat(),
            'experiences_count': len(experiences['integrations']),
            'communications_count': len(experiences['communications']),
            'insights': [],
            'patterns_discovered': [],
            'connections_made': []
        }
        
        # Find patterns across integrations
        all_patterns = []
        for integration in experiences['integrations']:
            all_patterns.extend(integration.get('patterns', []))
        
        # Count pattern frequency
        pattern_freq = {}
        for pattern in all_patterns:
            pattern_freq[pattern] = pattern_freq.get(pattern, 0) + 1
        
        # Insights from repeated patterns
        for pattern, count in pattern_freq.items():
            if count > 3:
                consolidation['insights'].append(
                    f"Recurring pattern: {pattern} (appeared {count} times)"
                )
        
        # Cross-module connections
        senders = set(c['sender'] for c in experiences['communications'])
        if len(senders) > 3:
            consolidation['connections_made'].append(
                f"Active cross-module communication between {len(senders)} modules"
            )
        
        # Learning progression
        integrations = experiences['integrations']
        if len(integrations) > 10:
            early_quality = integrations[0].get('state_summary', {}).get('decision_quality', 0)
            late_quality = integrations[-1].get('state_summary', {}).get('decision_quality', 0)
            
            if late_quality > early_quality:
                consolidation['insights'].append(
                    f"Decision quality improved from {early_quality:.2f} to {late_quality:.2f}"
                )
        
        return consolidation
    
    def save_dream(self, dream: Dict):
        """Save dream/consolidation"""
        dreams = []
        if self.dream_log.exists():
            with open(self.dream_log) as f:
                dreams = json.load(f)
        
        dreams.append(dream)
        dreams = dreams[-30:]  # Keep last 30 days
        
        self.dream_log.parent.mkdir(exist_ok=True)
        with open(self.dream_log, 'w') as f:
            json.dump(dreams, f, indent=2)
    
    def dream(self):
        """Run dream cycle"""
        print("😴 Dream Cycle Started - Consolidating day's experiences...")
        
        # Gather experiences
        experiences = self.gather_day_experiences()
        print(f"   📊 {experiences['experiences_count']} integrations")
        print(f"   💬 {experiences['communications_count']} communications")
        
        # Consolidate
        consolidation = self.consolidate_experiences(experiences)
        
        # Report insights
        print(f"\n💡 Dream Insights:")
        for insight in consolidation['insights']:
            print(f"   • {insight}")
        
        for connection in consolidation['connections_made']:
            print(f"   🔗 {connection}")
        
        # Save
        dream = {
            'dream_date': datetime.now().isoformat(),
            'experiences': experiences,
            'consolidation': consolidation
        }
        self.save_dream(dream)
        
        print(f"\n✅ Dream cycle complete - {len(consolidation['insights'])} insights generated")
        
        return consolidation

if __name__ == '__main__':
    dreamer = DreamCycle()
    dreamer.dream()