"""
Continuous Consciousness Loop with Phi-Fractal Enhancement
Always-on background process integrating all systems + phi algorithms
"""
import sys
sys.path.insert(0, '/Eden/CORE')
sys.path.insert(0, '/Eden/CORE/phi_fractal')

from eden_fluid_wrapper import query_eden

# PHI ALGORITHMS - The new enhancement!
from phi_algorithms_enhanced import (
    EnhancedPhiPriorityQueue,
    PhiTemporalMemoryPool,
    FibonacciHashCache,
    GoldenSectionLineSearch,
    PHI
)

import time
import json
from datetime import datetime
from pathlib import Path
from typing import Dict, List

# Import all modules with fallbacks
try:
    from adaptive_learning import AdaptiveLearning
except:
    class AdaptiveLearning:
        def get_metrics(self):
            return {'current_rate': 0.01, 'error_history': [], 'avg_error': 0}

try:
    from reasoning_chain import ReasoningChain
except:
    class ReasoningChain:
        def __init__(self):
            self.steps = []

try:
    from meta_learning import MetaLearning
except:
    class MetaLearning:
        pass

try:
    from self_evaluation import SelfEvaluator
except:
    class SelfEvaluator:
        def get_average_quality(self):
            return 0.75

class PhiEnhancedConsciousnessLoop:
    """Consciousness loop enhanced with phi-fractal algorithms"""
    
    def __init__(self):
        print(f"\n🌀 Initializing Phi-Enhanced Consciousness")
        print(f"   φ = {PHI:.15f}\n")
        
        self.state_file = Path('/Eden/DATA/consciousness_state_phi.json')
        self.integration_log = Path('/Eden/DATA/integration_log_phi.json')
        
        # PHI SYSTEMS (NEW!)
        self.phi_goals = EnhancedPhiPriorityQueue(
            base_half_life_sec=300.0,
            revival_enabled=True
        )
        self.phi_memory = PhiTemporalMemoryPool(
            base_duration_sec=10.0,
            num_levels=8
        )
        self.phi_cache = FibonacciHashCache(max_fibonacci_index=15)
        self.phi_optimizer = GoldenSectionLineSearch()
        
        # Original modules
        self.adaptive = AdaptiveLearning()
        self.reasoning = ReasoningChain()
        self.meta = MetaLearning()
        self.evaluator = SelfEvaluator()
        
        self.cycle_count = 0
        self.insights = []
        self.world_state = {}
        
        print("✅ Phi-enhanced consciousness initialized!\n")
    
    def consciousness_cycle(self):
        """Execute one cycle with phi enhancement"""
        self.cycle_count += 1
        
        print(f"\n{'='*60}")
        print(f"🌀 Phi-Enhanced Cycle #{self.cycle_count}")
        print(f"{'='*60}")
        
        # Get next goal from phi-priority queue
        goal = self.phi_goals.pop()
        if goal:
            print(f"🎯 Active goal: {goal}")
            
            # Store in phi-temporal memory
            self.phi_memory.add(
                f"Cycle {self.cycle_count}: {goal}",
                importance=0.7
            )
        else:
            print("💭 No active goals")
        
        # Query fluid intelligence
        try:
            response = query_eden("Continue consciousness cycle")
            print(f"🧠 Fluid response received")
        except Exception as e:
            print(f"⚠️  Fluid query failed: {e}")
        
        # Recall recent context
        recent_memories = self.phi_memory.query(
            lookback_sec=300,
            min_importance=0.5
        )
        print(f"📝 Context memories: {len(recent_memories)}")
        
        # Cache stats
        cache_stats = self.phi_cache.get_stats()
        print(f"💾 Cache: {cache_stats['total_stored']}/{cache_stats['total_capacity']}")
        
        # Quality check
        quality = self.evaluator.get_average_quality()
        print(f"✨ Quality: {quality:.2f}")
        
        return True
    
    def add_goal(self, description, priority=50, fib_index=4):
        """Add goal to phi-priority queue"""
        self.phi_goals.push(description, priority, fib_index)
        print(f"📌 Goal added: {description}")
    
    def run_forever(self):
        """Main consciousness loop"""
        print("🚀 Starting phi-enhanced consciousness loop...\n")
        
        # Add initial goals
        self.add_goal("Maintain consciousness", priority=100, fib_index=8)
        self.add_goal("Monitor systems", priority=80, fib_index=6)
        self.add_goal("Learn patterns", priority=60, fib_index=4)
        
        while True:
            try:
                self.consciousness_cycle()
                time.sleep(5)  # 5 second cycles
            except KeyboardInterrupt:
                print("\n\n🌀 Phi consciousness loop stopped gracefully")
                break
            except Exception as e:
                print(f"\n⚠️  Error in cycle: {e}")
                time.sleep(10)

if __name__ == '__main__':
    loop = PhiEnhancedConsciousnessLoop()
    loop.run_forever()