"""
Consolidated Memory - Human-like memory that scales
Recent: Detailed | Old: Summarized | Important: Never forgotten
"""
import json
from pathlib import Path
from datetime import datetime, timedelta
from collections import defaultdict

class ConsolidatedMemory:
    def __init__(self):
        self.recent_memories = []  # Last 100 experiences (detailed)
        self.consolidated_memories = {}  # Older summaries by week
        self.important_memories = []  # Never forget these
        self.load_memory()
    
    def load_memory(self):
        mem_file = Path("data/consolidated_memory.json")
        if mem_file.exists():
            with open(mem_file, 'r') as f:
                data = json.load(f)
                self.recent_memories = data.get('recent', [])
                self.consolidated_memories = data.get('consolidated', {})
                self.important_memories = data.get('important', [])
    
    def save_memory(self):
        mem_file = Path("data/consolidated_memory.json")
        mem_file.parent.mkdir(exist_ok=True)
        with open(mem_file, 'w') as f:
            json.dump({
                'recent': self.recent_memories,
                'consolidated': self.consolidated_memories,
                'important': self.important_memories
            }, f, indent=2)
    
    def calculate_importance(self, experience):
        """Score how important this memory is (0-10)"""
        score = 5  # Default
        
        # Increase importance for:
        if not experience.get('success', True):
            score += 2  # Failures are important to learn from
        
        if 'breakthrough' in experience.get('task', '').lower():
            score += 3  # Breakthroughs are critical
        
        task_type = experience.get('task_type', 'general')
        if task_type in ['error_recovery', 'self_improvement']:
            score += 2  # Learning events are important
        
        return min(score, 10)
    
    def add_experience(self, experience):
        """Add new experience with smart storage"""
        experience['timestamp'] = datetime.now().isoformat()
        experience['importance'] = self.calculate_importance(experience)
        
        # Always add to recent
        self.recent_memories.append(experience)
        
        # Keep only last 100 in detailed recent memory
        if len(self.recent_memories) > 100:
            old = self.recent_memories.pop(0)
            
            # If important, preserve forever
            if old['importance'] >= 8:
                self.important_memories.append(old)
            else:
                # Otherwise consolidate into weekly summary
                self._consolidate_old_memory(old)
        
        self.save_memory()
    
    def _consolidate_old_memory(self, memory):
        """Compress old memory into weekly summary"""
        timestamp = datetime.fromisoformat(memory['timestamp'])
        week_key = timestamp.strftime("%Y-W%U")  # Year-Week format
        
        if week_key not in self.consolidated_memories:
            self.consolidated_memories[week_key] = {
                'experiences': 0,
                'successes': 0,
                'failures': 0,
                'task_types': defaultdict(int),
                'key_learnings': []
            }
        
        summary = self.consolidated_memories[week_key]
        summary['experiences'] += 1
        
        if memory.get('success', False):
            summary['successes'] += 1
        else:
            summary['failures'] += 1
        
        task_type = memory.get('task_type', 'general')
        summary['task_types'][task_type] += 1
        
        # Keep only key learnings from consolidated memories
        if memory['importance'] >= 6:
            summary['key_learnings'].append({
                'task': memory.get('task', 'Unknown'),
                'outcome': memory.get('outcome', 'Unknown')
            })
            # Keep only top 10 learnings per week
            if len(summary['key_learnings']) > 10:
                summary['key_learnings'].pop(0)
    
    def recall_recent(self, n=10):
        """Get detailed recent memories"""
        return self.recent_memories[-n:]
    
    def recall_important(self):
        """Get memories that should never be forgotten"""
        return self.important_memories
    
    def get_weekly_summary(self, weeks_ago=0):
        """Get consolidated summary of a past week"""
        target_date = datetime.now() - timedelta(weeks=weeks_ago)
        week_key = target_date.strftime("%Y-W%U")
        return self.consolidated_memories.get(week_key, None)
    
    def get_memory_stats(self):
        """How much is remembered vs consolidated"""
        total_consolidated = sum(
            week['experiences'] 
            for week in self.consolidated_memories.values()
        )
        
        return {
            'recent_detailed': len(self.recent_memories),
            'important_preserved': len(self.important_memories),
            'consolidated_experiences': total_consolidated,
            'consolidated_weeks': len(self.consolidated_memories),
            'total_experiences': len(self.recent_memories) + total_consolidated + len(self.important_memories)
        }
    
    def demonstrate_scaling(self):
        """Show how memory stays manageable over time"""
        print("\n" + "="*70)
        print("🧠 CONSOLIDATED MEMORY - SCALABLE DESIGN")
        print("="*70)
        
        stats = self.get_memory_stats()
        
        print(f"\n📊 Current Memory Usage:")
        print(f"   Recent (detailed):     {stats['recent_detailed']} experiences")
        print(f"   Important (preserved): {stats['important_preserved']} experiences")
        print(f"   Consolidated (summary): {stats['consolidated_experiences']} → {stats['consolidated_weeks']} weeks")
        print(f"   Total tracked:         {stats['total_experiences']} experiences")
        
        print(f"\n📈 Projected Scaling:")
        print(f"   After 1 year:  ~52 weeks consolidated + 100 recent + ~50 important")
        print(f"   After 10 years: ~520 weeks consolidated + 100 recent + ~500 important")
        print(f"   Storage growth: O(weeks) not O(experiences)!")
        
        print(f"\n✅ Memory stays fast and manageable forever")
        print("="*70)

if __name__ == "__main__":
    print("CONSOLIDATED MEMORY TEST")
    
    memory = ConsolidatedMemory()
    
    # Add test experiences
    for i in range(150):  # More than the 100 detailed limit
        memory.add_experience({
            'task': f'Task {i}',
            'task_type': 'test',
            'success': i % 5 != 0,  # 80% success rate
            'outcome': 'completed'
        })
    
    # Show how it scales
    memory.demonstrate_scaling()
    
    print(f"\n💡 Recent memories: {len(memory.recall_recent(5))}")
    print(f"🌟 Important memories: {len(memory.recall_important())}")
    
    print("\n✅ CONSOLIDATED MEMORY OPERATIONAL")