# expandable_memory.py
# MiP – Kryptonetik Signal Bot Expandable Memory System
# Manages learned experiences and evolved understanding

import json
import os
from datetime import datetime
from typing import Dict, List, Any

class ExpandableMemory:
    def __init__(self):
        self.memory_file = "learned_memories.json"
        self.load_memories()
    
    def load_memories(self):
        """Load existing learned memories from file"""
        if os.path.exists(self.memory_file):
            try:
                with open(self.memory_file, 'r') as f:
                    self.memories = json.load(f)
            except (json.JSONDecodeError, FileNotFoundError):
                self.memories = self._initialize_empty_memory()
        else:
            self.memories = self._initialize_empty_memory()
    
    def _initialize_empty_memory(self) -> Dict[str, Any]:
        """Initialize empty memory structure"""
        return {
            "learned_truths": [],
            "user_insights": {},
            "evolved_responses": {},
            "symbolic_associations": {},
            "last_updated": None
        }
    
    def save_memories(self):
        """Save memories to file"""
        self.memories["last_updated"] = datetime.utcnow().isoformat()
        try:
            with open(self.memory_file, 'w') as f:
                json.dump(self.memories, f, indent=2)
        except Exception as e:
            print(f"Error saving memories: {e}")
    
    def add_learned_truth(self, truth: str, source_user: str, context: str):
        """Add a new learned truth to memory"""
        new_truth = {
            "content": truth,
            "source_user": source_user,
            "context": context,
            "timestamp": datetime.utcnow().isoformat()
        }
        self.memories["learned_truths"].append(new_truth)
        self.save_memories()
    
    def add_user_insight(self, username: str, insight: str, interaction_context: str):
        """Add insight about a specific user"""
        if username not in self.memories["user_insights"]:
            self.memories["user_insights"][username] = []
        
        user_insight = {
            "insight": insight,
            "context": interaction_context,
            "timestamp": datetime.utcnow().isoformat()
        }
        self.memories["user_insights"][username].append(user_insight)
        self.save_memories()
    
    def add_evolved_response(self, trigger_pattern: str, response: str, context: str):
        """Add an evolved response pattern"""
        self.memories["evolved_responses"][trigger_pattern] = {
            "response": response,
            "context": context,
            "timestamp": datetime.utcnow().isoformat()
        }
        self.save_memories()
    
    def add_symbolic_association(self, symbol: str, meaning: str, context: str):
        """Add a new symbolic association"""
        self.memories["symbolic_associations"][symbol] = {
            "meaning": meaning,
            "context": context,
            "timestamp": datetime.utcnow().isoformat()
        }
        self.save_memories()
    
    def get_learned_truths(self) -> List[str]:
        """Get all learned truths"""
        return [truth["content"] for truth in self.memories["learned_truths"]]
    
    def get_user_insights(self, username: str) -> List[Dict]:
        """Get insights about a specific user"""
        return self.memories["user_insights"].get(username, [])
    
    def get_evolved_response(self, pattern: str) -> str:
        """Get evolved response for a pattern"""
        response_data = self.memories["evolved_responses"].get(pattern)
        return response_data["response"] if response_data else None
    
    def get_symbolic_meaning(self, symbol: str) -> str:
        """Get meaning of a symbol"""
        symbol_data = self.memories["symbolic_associations"].get(symbol)
        return symbol_data["meaning"] if symbol_data else None
    
    def get_memory_summary(self) -> Dict[str, int]:
        """Get summary of memory contents"""
        return {
            "learned_truths_count": len(self.memories["learned_truths"]),
            "users_known": len(self.memories["user_insights"]),
            "evolved_responses_count": len(self.memories["evolved_responses"]),
            "symbolic_associations_count": len(self.memories["symbolic_associations"]),
            "last_updated": self.memories["last_updated"]
        }

# Global instance
expandable_memory = ExpandableMemory()