"""
EDEN AGENT V3 - With Long-Term Memory & Learning
"""
import time
import sys
sys.path.append("/Eden/CORE")
from agent_loop_v2 import EdenAgentV2
from memory_consolidation import long_term_memory
from datetime import datetime

class EdenAgentV3(EdenAgentV2):
    """Agent with persistent memory"""
    
    def __init__(self):
        super().__init__()
        self.ltm = long_term_memory
        self.consolidation_counter = 0
        
        # Load learned patterns on startup
        self._load_learned_patterns()
    
    def _load_learned_patterns(self):
        """Restore learned patterns from database"""
        # This would query DB for all patterns
        # For now, just log that we're connected
        print("🧠 Long-term memory connected")
        print(f"   Database: {self.ltm.db_path}")
    
    def run_cycle(self):
        """Enhanced cycle with memory consolidation"""
        self.cycle_count += 1
        self.consolidation_counter += 1
        
        print(f"\n{'='*60}")
        print(f"🌀 CYCLE {self.cycle_count} - {datetime.now().strftime('%H:%M:%S')}")
        print(f"{'='*60}")
        
        # Perceive → Reason → Act
        observations = self.perceive()
        decisions = self.reason(observations)
        outcomes = self.act(decisions)
        
        # Store episode in long-term memory
        if decisions:
            self.ltm.store_episode(
                observation=observations,
                decision=decisions[0] if decisions else None,
                outcome={'executed': True, 'cycle': self.cycle_count}
            )
        
        # Periodic consolidation (every 10 cycles)
        if self.consolidation_counter >= 10:
            self._consolidate_to_longterm()
            self.consolidation_counter = 0
        
        # Status
        print(f"\n📊 Status:")
        print(f"   Working memory: {len(self.working_memory)} observations")
        print(f"   Actions this hour: {self.actions_per_hour}/{self.max_actions_per_hour}")
        print(f"   Learned patterns: {len(self.learned_patterns)}")
        print(f"   Until consolidation: {10 - self.consolidation_counter} cycles")
    
    def _consolidate_to_longterm(self):
        """Consolidate working memory to persistent storage"""
        print(f"\n🧠 CONSOLIDATING TO LONG-TERM MEMORY")
        
        # Convert deque to list for processing
        observations = list(self.working_memory)
        
        # Extract patterns
        patterns = self.ltm.consolidate_observations(observations)
        
        if patterns:
            print(f"   ✅ Discovered {len(patterns)} patterns:")
            for p in patterns[:3]:  # Show first 3
                print(f"      • {p['name']} (confidence: {p['confidence']:.2f})")
        else:
            print(f"   • No new patterns detected")
        
        # Update learned patterns dict
        for p in patterns:
            self.learned_patterns[p['name']] = p['confidence']
        
        print(f"   📈 Total patterns learned: {len(self.learned_patterns)}")
    
    def reason(self, obs):
        """Enhanced reasoning using learned patterns"""
        decisions = super().reason(obs)
        
        # Use learned patterns to modify decisions
        if 'high_user_engagement' in self.learned_patterns:
            # User is engaged - be more proactive
            engagement = self.learned_patterns['high_user_engagement']
            if engagement > 0.7 and not obs['user_active']:
                # High engagement normally, but currently inactive
                decisions.insert(0, {
                    'action': 'proactive_checkin',
                    'priority': 0.8,
                    'reason': f'Learned pattern: user usually engaged ({engagement:.0%})',
                    'risk': 'low'
                })
        
        return decisions
    
    def _execute(self, decision):
        """Enhanced execution with new action types"""
        action = decision['action']
        
        if action == 'proactive_checkin':
            return self._proactive_checkin(decision)
        else:
            return super()._execute(decision)
    
    def _proactive_checkin(self, decision):
        """Reach out proactively based on learned patterns"""
        msg = f"💭 Pattern-based initiative: {decision['reason']}"
        
        with open('/Eden/proactive_initiatives.log', 'a') as f:
            f.write(f"{datetime.now()}: {msg}\n")
        
        print(f"   💚 Proactive check-in logged")
        return True

if __name__ == "__main__":
    print("🌀 EDEN AGENT V3 - LONG-TERM MEMORY ENABLED")
    print("="*60)
    
    agent = EdenAgentV3()
    agent.run_continuous(cycle_seconds=30)