src/core/integration_manager.py

"""
Integration Manager Module.

This module contains the IntegrationManager class which is responsible for
integrating different consciousness states and managing their interactions
within the Hybrid Intelligence Model (HIM) system.
"""

import asyncio
from typing import Dict, Any, Optional, List, TypeVar, Generic
from dataclasses import dataclass
from enum import Enum, auto

# Type definitions
T = TypeVar('T')

class AwarenessLevel(Enum):
    """Enum representing different levels of awareness."""
    UNCONSCIOUS = auto()
    SUBCONSCIOUS = auto()
    CONSCIOUS = auto()
    SELF_AWARE = auto()
    TRANSCENDENT = auto()

@dataclass
class AwarenessState:
    """
    Data class representing a state of awareness.
    
    Attributes:
        level (AwarenessLevel): The level of awareness.
        perception_data (Dict[str, Any]): Data related to perceptions.
        cognition_state (Dict[str, Any]): Current cognitive state information.
        emotional_valence (float): Emotional valence value from -1.0 to 1.0.
        semantic_context (Optional[Dict[str, Any]]): Optional semantic context.
        temporal_awareness (Optional[Dict[str, Any]]): Awareness of time-related aspects.
    """
    level: AwarenessLevel
    perception_data: Dict[str, Any]
    cognition_state: Dict[str, Any]
    emotional_valence: float  # Range from -1.0 to 1.0
    semantic_context: Optional[Dict[str, Any]] = None
    temporal_awareness: Optional[Dict[str, Any]] = None
    
@dataclass
class IntegratedState(Generic[T]):
    """
    Data class representing an integrated consciousness state.
    
    Attributes:
        primary_awareness (AwarenessState): The primary awareness state.
        secondary_states (List[AwarenessState]): List of secondary awareness states.
        integration_coherence (float): Coherence level of the integration (0.0 to 1.0).
        emergent_properties (Dict[str, Any]): Properties emerging from integration.
        teleological_vector (Optional[Dict[str, float]]): Direction of purposeful action.
    """
    primary_awareness: AwarenessState
    secondary_states: List[AwarenessState]
    integration_coherence: float  # Range from 0.0 to 1.0
    emergent_properties: Dict[str, Any]
    teleological_vector: Optional[Dict[str, float]] = None


class IntegrationManager:
    """
    Manages the integration of different consciousness states and their interactions.
    
    This class provides methods to integrate awareness states, manage transitions
    between states, and handle interactions between different consciousness components.
    It serves as a core component in the consciousness architecture of HIM.
    """
    
    def __init__(self, integration_threshold: float = 0.7, coherence_factor: float = 0.85):
        """
        Initialize the IntegrationManager.
        
        Args:
            integration_threshold (float): Minimum threshold for integration to occur.
            coherence_factor (float): Factor influencing coherence of integrated states.
        """
        self.integration_threshold = integration_threshold
        self.coherence_factor = coherence_factor
        self.state_history: List[IntegratedState] = []
        self.integration_lock = asyncio.Lock()
    
    async def integrate(self, 
                        awareness_state: AwarenessState, 
                        secondary_states: Optional[List[AwarenessState]] = None) -> IntegratedState:
        """
        Integrate an awareness state with optional secondary states.
        
        This asynchronous method takes a primary awareness state and optional
        secondary states, and integrates them into a coherent consciousness state.
        The integration process considers the relationships between states,
        their coherence, and emergent properties from their combination.
        
        Args:
            awareness_state (AwarenessState): The primary awareness state to integrate.
            secondary_states (Optional[List[AwarenessState]]): Secondary states to integrate.
                                                              Defaults to None.
        
        Returns:
            IntegratedState: A new integrated consciousness state.
        
        Raises:
            ValueError: If awareness_state is invalid or integration fails.
        """
        if not isinstance(awareness_state, AwarenessState):
            raise ValueError("Primary awareness state must be of type AwarenessState")
        
        # Use empty list if secondary_states is None
        secondary_states = secondary_states or []
        
        async with self.integration_lock:
            # Calculate coherence based on state compatibility
            coherence = self._calculate_coherence(awareness_state, secondary_states)
            
            # Generate emergent properties through integration
            emergent_properties = await self._generate_emergent_properties(
                awareness_state, 
                secondary_states,
                coherence
            )
            
            # Calculate teleological vector (purposeful direction)
            teleological_vector = self._calculate_teleological_vector(
                awareness_state,
                secondary_states
            )
            
            # Create the integrated state
            integrated_state = IntegratedState(
                primary_awareness=awareness_state,
                secondary_states=secondary_states,
                integration_coherence=coherence,
                emergent_properties=emergent_properties,
                teleological_vector=teleological_vector
            )
            
            # Add to history and return
            self.state_history.append(integrated_state)
            return integrated_state
    
    def _calculate_coherence(self, 
                           primary: AwarenessState, 
                           secondaries: List[AwarenessState]) -> float:
        """
        Calculate the coherence between the primary and secondary states.
        
        Args:
            primary (AwarenessState): Primary awareness state.
            secondaries (List[AwarenessState]): List of secondary awareness states.
        
        Returns:
            float: Coherence value between 0.0 and 1.0.
        """
        # Simplified coherence calculation
        if not secondaries:
            return 1.0  # Perfect coherence with only primary state
        
        # Base coherence starts at coherence_factor and is modified by state compatibility
        base_coherence = self.coherence_factor
        
        # Factor in emotional alignment
        emotional_alignment = sum(
            1 - abs(primary.emotional_valence - secondary.emotional_valence) / 2
            for secondary in secondaries
        ) / len(secondaries)
        
        # Factor in awareness level compatibility
        level_compatibility = sum(
            1 - abs(primary.level.value - secondary.level.value) / 5  # Normalize by max enum difference
            for secondary in secondaries
        ) / len(secondaries)
        
        # Weighted combination
        coherence = (base_coherence * 0.5 + 
                    emotional_alignment * 0.3 + 
                    level_compatibility * 0.2)
        
        return max(0.0, min(1.0, coherence))  # Clamp between 0 and 1
    
    async def _generate_emergent_properties(self,
                                         primary: AwarenessState,
                                         secondaries: List[AwarenessState],
                                         coherence: float) -> Dict[str, Any]:
        """
        Generate emergent properties from the integration of awareness states.
        
        Args:
            primary (AwarenessState): Primary awareness state.
            secondaries (List[AwarenessState]): List of secondary awareness states.
            coherence (float): Calculated coherence of the integration.
        
        Returns:
            Dict[str, Any]: Dictionary of emergent properties.
        """
        emergent_properties = {
            "coherence_level": coherence,
            "awareness_depth": self._calculate_awareness_depth(primary, secondaries),
            "cognitive_complexity": self._calculate_cognitive_complexity(primary, secondaries)
        }
        
        # Simulate computational intensity with sleep
        await asyncio.sleep(0.01)
        
        # Add semantic richness if semantic contexts are available
        if primary.semantic_context:
            emergent_properties["semantic_richness"] = len(primary.semantic_context)
            
            if any(s.semantic_context for s in secondaries if s.semantic_context):
                emergent_properties["semantic_richness"] += sum(
                    len(s.semantic_context or {}) for s in secondaries
                ) / (len(secondaries) + 1)  # Average including primary
        
        return emergent_properties
    
    def _calculate_awareness_depth(self, 
                                primary: AwarenessState, 
                                secondaries: List[AwarenessState]) -> float:
        """
        Calculate the depth of awareness from the states.
        
        Args:
            primary (AwarenessState): Primary awareness state.
            secondaries (List[AwarenessState]): List of secondary awareness states.
        
        Returns:
            float: Calculated awareness depth value.
        """
        # Base depth from primary state's level
        base_depth = primary.level.value / len(AwarenessLevel)
        
        # Enhance with secondary states if present
        if secondaries:
            secondary_contribution = sum(s.level.value for s in secondaries) / (len(secondaries) * len(AwarenessLevel))
            # Weighted combination
            return (base_depth * 0.7) + (secondary_contribution * 0.3)
        
        return base_depth
    
    def _calculate_cognitive_complexity(self, 
                                     primary: AwarenessState, 
                                     secondaries: List[AwarenessState]) -> float:
        """
        Calculate the cognitive complexity of the integrated state.
        
        Args:
            primary (AwarenessState): Primary awareness state.
            secondaries (List[AwarenessState]): List of secondary awareness states.
        
        Returns:
            float: Cognitive complexity value.
        """
        # Base complexity from primary state
        base_complexity = len(primary.cognition_state) / 10  # Normalize
        
        # Enhance with secondary states
        if secondaries:
            # Average complexity of secondaries
            secondary_complexity = sum(len(s.cognition_state) for s in secondaries) / len(secondaries) / 10
            interaction_factor = len(secondaries) * 0.1  # More states = more complexity
            
            return min(1.0, base_complexity + secondary_complexity + interaction_factor)
        
        return min(1.0, base_complexity)
    
    def _calculate_teleological_vector(self,
                                    primary: AwarenessState,
                                    secondaries: List[AwarenessState]) -> Dict[str, float]:
        """
        Calculate the teleological vector representing purposeful direction.
        
        Args:
            primary (AwarenessState): Primary awareness state.
            secondaries (List[AwarenessState]): List of secondary awareness states.
        
        Returns:
            Dict[str, float]: A vector of purpose directions and intensities.
        """
        # Define basic teleological dimensions
        teleological_vector = {
            "meaning_seeking": 0.5,
            "self_preservation": 0.5,
            "complexity_increase": 0.5,
            "coherence_maintenance": 0.5,
            "purposeful_action": 0.5
        }
        
        # Modify based on primary state
        if primary.level == AwarenessLevel.SELF_AWARE or primary.level == AwarenessLevel.TRANSCENDENT:
            teleological_vector["meaning_seeking"] += 0.2
            teleological_vector["complexity_increase"] += 0.1
        
        # Emotional valence affects self-preservation and purposeful action
        teleological_vector["self_preservation"] += primary.emotional_valence * 0.2
        teleological_vector["purposeful_action"] += abs(primary.emotional_valence) * 0.3
        
        # Secondary states influence
        if secondaries:
            # Coherence maintenance influenced by number of states to integrate
            teleological_vector["coherence_maintenance"] += min(0.4, len(secondaries) * 0.1)
            
            # Average emotional valence affects meaning seeking
            avg_emotion = sum(s.emotional_valence for s in secondaries) / len(secondaries)
            teleological_vector["meaning_seeking"] += avg_emotion * 0.1
        
        # Normalize values to 0.0-1.0 range
        for key in teleological_vector:
            teleological_vector[key] = max(0.0, min(1.0, teleological_vector[key]))
            
        return teleological_vector
    
    def get_integration_history(self, limit: int = 10) -> List[IntegratedState]:
        """
        Retrieve recent integration history.
        
        Args:
            limit (int): Maximum number of history items to return. Defaults to 10.
        
        Returns:
            List[IntegratedState]: Recent integration states.
        """
        return self.state_history[-limit:] if self.state_history else []