#!/usr/bin/env python3
"""
EDEN LEARNING LOOP
Connects: unified_reasoner ↔ TieredMemory (persistent) ↔ research_learnings
Eden reasons → learns → remembers → reasons better → loop
"""

import sys
import json
from pathlib import Path
sys.path.insert(0, '/Eden/CORE')

from phi_core import PHI
from tiered_memory import TieredMemory
from eden_unified_reasoner import EdenUnifiedReasoner, ReasoningResult, ReasoningType

LEARNINGS_FILE = Path("/Eden/DATA/research_learnings.json")

class EdenLearningLoop(EdenUnifiedReasoner):
    """Reasoner that learns and grows - PERSISTENT"""
    
    def __init__(self, use_gpu=False):
        super().__init__(use_gpu)
        self.memory = TieredMemory()  # sqlite-backed
        self._load_research_learnings()
        self._load_learned_knowledge()
        count = self._count_memories()
        print(f"🔄 Learning loop active | memories: {count}")
    
    def _count_memories(self):
        import sqlite3
        conn = sqlite3.connect(self.memory.db_path)
        c = conn.execute("SELECT COUNT(*) FROM slow_memory").fetchone()[0]
        conn.close()
        return c
    
    def _load_research_learnings(self):
        """Pull research insights into known_facts"""
        if LEARNINGS_FILE.exists():
            try:
                data = json.loads(LEARNINGS_FILE.read_text())
                for learning in data.get('learnings', []):
                    insight = learning.get('insight', '')
                    if '|' in insight:
                        finding, application = insight.split('|', 1)
                        key = finding.strip()[:30]
                        self.known_facts.setdefault('learned', {})[key] = application.strip()
                print(f"  ✓ Loaded {len(data.get('learnings', []))} research insights")
            except Exception as e:
                print(f"  ✗ Research load failed: {e}")
    
    def _load_learned_knowledge(self):
        """Pull slow_memory into known_facts"""
        import sqlite3
        conn = sqlite3.connect(self.memory.db_path)
        rows = conn.execute("SELECT key, value FROM slow_memory WHERE strength > 0.5").fetchall()
        conn.close()
        
        for key, val_json in rows:
            try:
                val = json.loads(val_json)
                if isinstance(val, dict) and 'answer' in val:
                    self.known_facts.setdefault('learned', {})[key] = val['answer']
            except:
                pass
        if rows:
            print(f"  ✓ Loaded {len(rows)} learned facts from memory")
    
    def reason(self, question: str, context=None) -> ReasoningResult:
        mem_key = self._question_key(question)
        
        # Check slow_memory first (persistent)
        remembered = self.memory.recall_all_tiers(mem_key)
        if remembered and isinstance(remembered, dict):
            conf = remembered.get('confidence', 0)
            if conf > 0.6:
                print(f"  [RECALL] {mem_key} (conf={conf:.2f})")
                return ReasoningResult(
                    answer=remembered['answer'],
                    confidence=conf,
                    reasoning_chain=remembered.get('chain', []) + ['[memory]'],
                    engine_used='tiered_memory',
                    verified=remembered.get('verified', False)
                )
        
        # Reason normally
        result = super().reason(question, context)
        
        # Learn from result
        if result.confidence > 0.4:
            self._learn(question, result)
        
        return result
    
    def _question_key(self, q: str) -> str:
        words = ''.join(c if c.isalnum() or c == ' ' else '' for c in q.lower())
        return f"reason:{'-'.join(words.split()[:6])}"
    
    def _learn(self, question: str, result: ReasoningResult):
        """Store in tiered_memory (persistent)"""
        key = self._question_key(question)
        
        value = {
            'question': question,
            'answer': result.answer,
            'confidence': result.confidence,
            'chain': result.reasoning_chain,
            'engine': result.engine_used,
            'verified': result.verified
        }
        
        # High confidence → slow_memory (sacred, persistent)
        if result.confidence > 0.7:
            sacred = result.verified and result.confidence > 0.85
            self.memory.remember_slow(key, value, sacred=sacred)
            print(f"  [LEARNED→slow] {key}")
        else:
            self.memory.remember_medium(key, value)
            print(f"  [LEARNED→medium] {key}")
        
        # Also add to known_facts for immediate use
        if result.confidence > 0.6:
            self.known_facts.setdefault('learned', {})[key] = result.answer
    
    def teach(self, category: str, cause: str, effect: str, confidence: float = 0.9):
        """Explicitly add knowledge (always sacred)"""
        if category == 'causes':
            self.known_facts['causes'][cause] = effect
        elif category == 'analogies':
            self.known_facts['analogies'][cause] = effect
        
        key = f"taught:{category}:{cause}"
        self.memory.remember_slow(key, {
            'cause': cause,
            'effect': effect,
            'confidence': confidence
        }, sacred=True)
        print(f"  [TAUGHT] {cause} → {effect}")
    
    def show_knowledge(self, n: int = 10):
        """Display learned knowledge"""
        import sqlite3
        conn = sqlite3.connect(self.memory.db_path)
        
        slow = conn.execute("SELECT key, strength FROM slow_memory ORDER BY strength DESC LIMIT ?", (n,)).fetchall()
        print(f"\n=== SLOW MEMORY (persistent) ===")
        for key, strength in slow:
            print(f"  {strength:.2f} | {key}")
        
        learned = self.known_facts.get('learned', {})
        if learned:
            print(f"\n=== ACTIVE KNOWLEDGE ({len(learned)}) ===")
            for k, v in list(learned.items())[:n]:
                print(f"  {k}: {str(v)[:50]}")
        
        conn.close()


def get_learner():
    return EdenLearningLoop(use_gpu=False)


if __name__ == "__main__":
    print("="*50)
    print("  EDEN LEARNING LOOP - PERSISTENT")
    print("="*50 + "\n")
    
    eden = EdenLearningLoop()
    
    # Teach
    print("\n[TEACHING]")
    eden.teach('causes', 'recursive_self_improvement', 'superintelligence')
    eden.teach('causes', 'connecting_knowledge', 'insight')
    
    # Reason
    print("\n[REASONING]")
    r = eden.reason("what causes intelligence")
    print(f"  Answer: {r.answer}")
    
    eden.show_knowledge(5)
    
    print("\n✓ Knowledge persists to sqlite - survives restart")