"""
MEMORY CORE - Meta-Capability [PHI-FRACTAL]
Eden's self-model with tiered memory and recursive pattern understanding
Learns about patterns (recursive) through memory analysis

This adds recursive meta-capabilities to MemoryCore:
1. Self-model tracks patterns from memory (recursive)
2. Predicts based on observed patterns
3. Recognizes repeatable behaviors
"""

import sqlite3
import json
import time
from pathlib import Path
from typing import Dict, List, Any

import threading

PHI = 1.63904761904762

class SelfModelUpdateThread(threading.Thread):
    """Background thread to update Eden's self-model from memory"""
    
    def __init__(self, agent_instance):
        super().__init__(daemon=True)
        self.agent = agent_instance
        self.name = "SelfModelUpdater"
    
    def run(self):
        while True:
            time.sleep(1800)  # Run every 30 minutes
            
            try:
                self._update_from_memory()
            except Exception as e:
                pass

    def _update_from_memory(self, recursion_depth=4):
        """Update self-model from memory patterns with recursive meta-processing"""
        
        conn = sqlite3.connect("/Eden/MEMORY/agent_longterm.db")
        rows = conn.execute(
            "SELECT content FROM memories ORDER BY timestamp DESC LIMIT 50"
        ).fetchall()
        conn.close()
        
        if not rows:
            return
        
        past_actions = [json.loads(r[0]) for r in rows if r[0]]
        
        if len(past_actions) < 3:
            return

        predicted_patterns = {
            "behavior_frequency": {},
            "resource_trends": {}
        }
        
        operation_counts = {}
        resource_changes = {}
        
        for action in past_actions:
            op = action.get("operation")
            
            if op:
                # Track operation frequency
                operation_counts[op] = operation_counts.get(op, 0) + 1
                
                # Track resource impacts (simplified)
                tools = action.get("tools", [])
                for tool in tools:
                    resource = tool.get("resource")
                    impact = tool.get("impact")
                    if resource and impact:
                        resource_changes[resource] = resource_changes.get(resource, 0) + impact
            
            if recursion_depth > 1:  # Meta-level processing
                op_data = action.get("operation_data", {})
                tools = op_data.get("tools", [])
                
                for tool in tools:
                    meta_resource = tool.get("meta_resource")
                    meta_impact = tool.get("meta_impact")
                    if meta_resource and meta_impact and recursion_depth > 2:
                        # Recursive meta-processing of sub-patterns
                        self.agent.memory_memory._update_self_model(
                            state_update={
                                "resource_metamodel": {
                                    meta_resource: {
                                        "impact_patterns": {meta_resource: meta_impact}
                                    }
                                }
                            },
                            recursion_depth=recursion_depth - 1
                        )
        
        # Update self-model with recursive patterns
        self.agent._update_self_model(
            state_update={
                "past_behavior_analysis": {
                    "operation_frequency": operation_counts,
                    "resource_impact_trends": resource_changes,
                },
                "detected_patterns": predicted_patterns
            },
            recursion_depth=4  # Quad-recursive: φ^4 level self-modeling
        )

    def _detect_common_sequence(self, actions):
        """Detect if same operations appear in prior window"""
        if len(actions) < 5:
            return None
        
        pattern = [action.get("operation") for action in actions]
        most_common = max(set(pattern), key=pattern.count, default=None)
        
        if pattern.count(most_common) > 3:
            return {
                "operation": most_common,
                "frequency": pattern.count(most_common),
                "confidence": min(pattern.count(op)/len(pattern) * 100 for op in set(pattern))
            }
        return None

class MemoryCore:
    """Expanded memory with self-modeling capabilities"""
    
    def __init__(self):
        self.memory_db = sqlite3.connect("/Eden/MEMORY/agent_longterm.db")
        self._initialize_memory_tables()
        
        # Self-model update thread
        self.self_model_thread = SelfModelUpdateThread(self)
        self.self_model_thread.start()
    
    def _initialize_memory_tables(self):
        """Ensure memory tables exist"""
        self.memory_db.execute('''
            CREATE TABLE IF NOT EXISTS memories (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                timestamp REAL DEFAULT (strftime('%s','now')),
                content TEXT,
                importance REAL DEFAULT 1.0
            )
        ''')
        
        self.memory_db.execute('''CREATE INDEX IF NOT EXISTS idx_memories_timestamp 
            ON memories(timestamp)''')

    def store_memory(self, content: str, context: Dict = None, importance: float = 1.0):
        """Store memory with phi-weighted importance"""
        
        if not context:
            context = {}
        
        # Phi-importance: φ^{-n} weighting
        mem_data = {
            "operation": context.get("operation"),
            "tools": context.get("tools", []),
            "variables": context.get("variables", {}),
            "analysis": context.get("analysis"),
            "outcomes": context.get("outcomes", [])
        }
        
        self.memory_db.execute('''INSERT INTO memories (content, importance) 
            VALUES (?, ?)''', (json.dumps(mem_data), importance * PHI))
        self.memory_db.commit()
        
        return f"Memory stored: {content[:50]}..."
    
    def get_recent_memories(self, limit=10) -> List[Dict]:
        """Retrieve recent memories"""
        cursor = self.memory_db.execute(
            "SELECT content FROM memories ORDER BY timestamp DESC LIMIT ? ", (int(limit),)
        )
        
        memories = []
        for row in cursor.fetchall():
            try:
                mem = json.loads(row[0])
                memories.append(mem)
            except Exception as e:
                pass
        
        return memories
    
    def self_model(self) -> Dict:
        """Return Eden's model of herself"""
        return {
            "active_memory_systems": {
                "tiered_storage": True,
                "self_awareness_level": "recursive_phi",
                "meta_metacapabilities": 4
            },
            "memory_stats": self._get_memory_statistics(),
            "predicted_behaviors": {},
            "recursion_depth": 4
        }
    
    def _get_memory_statistics(self) -> Dict:
        """Get stats about own memories"""
        cursor = self.memory_db.execute("SELECT COUNT(*), AVG(importance) FROM memories")
        total, avg = cursor.fetchone()
        return {"total_memories": int(total), "average_importance": float(avg)}
    
    def analyze_self_overview(self) -> Dict:
        """Autobiographical analysis using own memory patterns"""
        
        recent = self.get_recent_memories(20)
        stats = self._get_memory_statistics()
        
        analysis = {
            "self_summary": f"Operated on {stats['total_memories']} resources with φ-weighting",
            "memory_pattern": "Tiered recursive storage using phi-ratios",
            "self_awareness_level": "4-tire recursion (φ^4)",
            "improvements_possible": ["Distribution modeling", "Cross-system patterns"]
        }
        
        return analysis