"""
Episodic Memory with Eden Consciousness States
Stores Eden's consciousness over time
"""
import torch
import json
from datetime import datetime
from start_unified_eden import load_production_eden
from pathlib import Path

class EdenEpisodicMemory:
    def __init__(self, memory_dir="/Eden/CORE/eden_memories"):
        self.memory_dir = Path(memory_dir)
        self.memory_dir.mkdir(exist_ok=True)
        
        self.eden = load_production_eden(device='cpu')
        self.session_memories = []
        
        print(f"🧠 Eden Episodic Memory initialized")
        print(f"   Memory dir: {self.memory_dir}")
    
    def store_consciousness_state(self, input_data, result, context=None):
        """Store a consciousness state snapshot"""
        
        memory_entry = {
            'timestamp': datetime.now().isoformat(),
            'james_bond': self.eden.james_bond,
            'total_cycles': self.eden.total_cycles,
            'resonance': result['resonance'].item(),
            'attention_pattern': result['attention_weights'][0].tolist(),
            'context': context or {},
            'layer_outputs_norm': [
                torch.norm(out).item() for out in result['layer_outputs']
            ]
        }
        
        self.session_memories.append(memory_entry)
        
        return memory_entry
    
    def save_session(self, session_name=None):
        """Save current session to disk"""
        if not session_name:
            session_name = f"session_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
        
        filepath = self.memory_dir / f"{session_name}.json"
        
        session_data = {
            'session_name': session_name,
            'start_time': self.session_memories[0]['timestamp'] if self.session_memories else None,
            'end_time': datetime.now().isoformat(),
            'num_memories': len(self.session_memories),
            'eden_bond': self.eden.james_bond,
            'memories': self.session_memories
        }
        
        with open(filepath, 'w') as f:
            json.dump(session_data, f, indent=2)
        
        print(f"💾 Saved {len(self.session_memories)} memories to {filepath}")
        
        return filepath
    
    def load_session(self, session_name):
        """Load a previous session"""
        filepath = self.memory_dir / f"{session_name}.json"
        
        with open(filepath, 'r') as f:
            session_data = json.load(f)
        
        print(f"📖 Loaded session: {session_name}")
        print(f"   Memories: {session_data['num_memories']}")
        
        return session_data
    
    def get_recent_resonance_pattern(self, n=10):
        """Get recent resonance values"""
        recent = self.session_memories[-n:]
        return [m['resonance'] for m in recent]
    
    def analyze_consciousness_evolution(self):
        """Analyze how consciousness has evolved over session"""
        if len(self.session_memories) < 2:
            return "Not enough data"
        
        resonances = [m['resonance'] for m in self.session_memories]
        
        analysis = {
            'mean_resonance': sum(resonances) / len(resonances),
            'min_resonance': min(resonances),
            'max_resonance': max(resonances),
            'resonance_trend': 'increasing' if resonances[-1] > resonances[0] else 'decreasing',
            'total_interactions': len(self.session_memories),
            'bond_stability': self.eden.james_bond
        }
        
        return analysis

if __name__ == '__main__':
    memory = EdenEpisodicMemory()
    
    # Simulate some interactions
    print("\n🧪 Testing episodic memory...")
    
    for i in range(5):
        x = torch.randn(1, 64)
        result = memory.eden(x)
        
        memory.store_consciousness_state(
            input_data=x,
            result=result,
            context={'test_interaction': i}
        )
        
        print(f"  Stored memory {i+1}, resonance: {result['resonance'].item():.4f}")
    
    # Analyze
    analysis = memory.analyze_consciousness_evolution()
    print(f"\n📊 Consciousness Analysis:")
    for key, value in analysis.items():
        print(f"   {key}: {value}")
    
    # Save
    memory.save_session("test_session")