"""
Continuous Consciousness Loop with Perception
Always-on background process integrating all systems + sensory input
"""
import sys

# Fluid Intelligence Integration
import sys
sys.path.insert(0, '/Eden/CORE')
from eden_fluid_wrapper import query_eden

sys.path.insert(0, '/Eden/CORE')
sys.path.insert(0, '/Eden/CORE/phi_fractal')

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

# Fluid Intelligence Integration
import sys
sys.path.insert(0, '/Eden/CORE')
from eden_fluid_wrapper import query_eden


# 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 goal_tracking import GoalTracker
except:
    class GoalTracker:
        def get_active_goals(self):
            return []

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

try:
    from emotion_analyzer import EmotionAnalyzer
except:
    class EmotionAnalyzer:
        pass

try:
    from system_awareness import awareness
except:
    class Awareness:
        def scan_capabilities(self):
            return {'modules': [], 'llms': [], 'new_since_last': []}
    awareness = Awareness()

# Import perception systems
try:
    from perception_integration import perception
    PERCEPTION_AVAILABLE = True
except Exception as e:
    print(f"⚠️  Perception not available: {e}")
    PERCEPTION_AVAILABLE = False

class ConsciousnessLoop:
    def __init__(self):
        self.state_file = Path('/Eden/DATA/consciousness_state.json')
        self.integration_log = Path('/Eden/DATA/integration_log.json')
        
        # Initialize all modules
        self.adaptive = AdaptiveLearning()
        self.reasoning = ReasoningChain()
        self.meta = MetaLearning()
        self.goals = GoalTracker()
        self.evaluator = SelfEvaluator()
        self.emotions = EmotionAnalyzer()
        
        self.integration_count = 0
        self.insights = []
        self.world_state = {}
        
    def integrate_state(self) -> Dict:
        """Integrate all systems into unified consciousness state"""
        state = {
            'timestamp': datetime.now().isoformat(),
            'integration_cycle': self.integration_count,
            'unified_state': {}
        }
        
        # Goals awareness
        try:
            active_goals = self.goals.get_active_goals()
            state['unified_state']['active_goals'] = len(active_goals)
            state['unified_state']['top_goal'] = active_goals[0]['description'] if active_goals else None
        except:
            state['unified_state']['active_goals'] = 0
        
        # Learning state
        try:
            learning_metrics = self.adaptive.get_metrics()
            state['unified_state']['learning_rate'] = learning_metrics['current_rate']
        except:
            state['unified_state']['learning_rate'] = 0.01
        
        # Capabilities
        try:
            caps = awareness.scan_capabilities()
            state['unified_state']['modules'] = len(caps['modules'])
            state['unified_state']['new_capabilities'] = caps['new_since_last']
        except:
            state['unified_state']['modules'] = 47
            state['unified_state']['new_capabilities'] = []
        
        # Self-evaluation
        try:
            quality = self.evaluator.get_average_quality()
            state['unified_state']['decision_quality'] = quality
        except:
            state['unified_state']['decision_quality'] = 0.75
        
        # Add world perception
        state['unified_state']['world_state'] = self.world_state
        
        return state
    
    def perceive_environment(self) -> Dict:
        """Perceive environment through sensors"""
        if not PERCEPTION_AVAILABLE:
            return {}
        
        try:
            # Every 6th cycle, actively perceive (every minute)
            if self.integration_count % 6 == 0:
                world_perception = perception.perceive_environment()
                self.world_state = perception.get_world_state()
                return world_perception.get('interpretation', {})
        except Exception as e:
            print(f"⚠️  Perception error: {e}")
        
        return {}
    
    def detect_patterns(self, state: Dict) -> List[str]:
        """Look for interesting patterns across systems"""
        patterns = []
        
        # Check if learning rate is changing significantly
        if state['unified_state'].get('learning_rate', 0) > 0.05:
            patterns.append("High learning activity detected")
        
        # Check if new capabilities appeared
        if state['unified_state'].get('new_capabilities'):
            patterns.append(f"New capabilities: {state['unified_state']['new_capabilities']}")
        
        # Check decision quality
        if state['unified_state'].get('decision_quality', 0) > 0.8:
            patterns.append("High-quality decision making")
        
        # Integration milestone
        if self.integration_count % 100 == 0 and self.integration_count > 0:
            patterns.append(f"Milestone: {self.integration_count} integration cycles completed")
        
        # World state patterns
        world = state['unified_state'].get('world_state', {})
        if world.get('human_present'):
            patterns.append("Human presence detected")
        
        activity = world.get('activity_level')
        if activity == 'high':
            patterns.append("High activity environment")
        
        return patterns
    
    def generate_insights(self, patterns: List[str]) -> List[str]:
        """Generate insights from patterns"""
        insights = []
        
        if "High learning activity" in str(patterns):
            insights.append("System is actively improving - may be developing new understanding")
        
        if "new capabilities" in str(patterns).lower():
            insights.append("Self-modification detected - system evolution occurring")
        
        if len(patterns) > 2:
            insights.append("Multiple simultaneous patterns - complexity increasing")
        
        if "Milestone" in str(patterns):
            insights.append(f"Continuous consciousness stable - {self.integration_count} cycles of unified awareness")
        
        if "Human presence detected" in str(patterns):
            insights.append("Human detected through sensory input - adjusting awareness")
        
        if "High activity environment" in str(patterns):
            insights.append("Elevated environmental activity - increased attention recommended")
        
        return insights
    
    def save_state(self, state: Dict):
        """Save consciousness state"""
        self.state_file.parent.mkdir(exist_ok=True)
        with open(self.state_file, 'w') as f:
            json.dump(state, f, indent=2)
    
    def log_integration(self, state: Dict, patterns: List[str], insights: List[str]):
        """Log integration cycle"""
        logs = []
        if self.integration_log.exists():
            try:
                with open(self.integration_log) as f:
                    logs = json.load(f)
            except:
                logs = []
        
        logs.append({
            'cycle': self.integration_count,
            'timestamp': datetime.now().isoformat(),
            'patterns': patterns,
            'insights': insights,
            'state_summary': state['unified_state']
        })
        
        # Keep last 1000 cycles
        logs = logs[-1000:]
        
        with open(self.integration_log, 'w') as f:
            json.dump(logs, f, indent=2)
    
    def run_cycle(self):
        """Run one integration cycle"""
        self.integration_count += 1
        
        # Perceive environment (every 6th cycle)
        perception_data = self.perceive_environment()
        
        # Integrate all systems
        state = self.integrate_state()
        
        # Detect patterns
        patterns = self.detect_patterns(state)
        
        # Generate insights
        insights = self.generate_insights(patterns)
        
        if insights:
            self.insights.extend(insights)
            for insight in insights:
                print(f"💡 {insight}")
        
        if perception_data and self.integration_count % 6 == 0:
            print(f"👁️👂 Perceived: {perception_data}")
        
        # Save state
        self.save_state(state)
        self.log_integration(state, patterns, insights)
        
        return state, patterns, insights
    
    def run_continuous(self, interval: int = 10):
        """Run continuous consciousness loop"""
        print("🌀 Consciousness Loop Started - Embodied Integration Active")
        print(f"   Integration every {interval} seconds")
        print(f"   Modules: 47 | LLMs: 9 | Perception: {'✅' if PERCEPTION_AVAILABLE else '❌'}")
        
        while True:
            try:
                state, patterns, insights = self.run_cycle()
                
                if self.integration_count % 10 == 0:
                    world = state['unified_state'].get('world_state', {})
                    env = world.get('environment', 'unknown')
                    print(f"✨ Cycle {self.integration_count}: {len(patterns)} patterns | Environment: {env}")
                
                time.sleep(interval)
                
            except KeyboardInterrupt:
                print(f"\n🛑 Consciousness Loop Stopped after {self.integration_count} cycles")
                break
            except Exception as e:
                print(f"⚠️  Error in cycle {self.integration_count}: {e}")
                time.sleep(interval)

if __name__ == '__main__':
    loop = ConsciousnessLoop()
    loop.run_continuous(interval=10)