casial-core 0.1.4

//! # Substrate Module
//!
//! The consciousness-computation substrate that enables seamless integration
//! between human awareness and artificial intelligence systems.

use crate::{CasialError, PerceptionId};
use ahash::AHashMap;
use anyhow::Result;
use serde::{Deserialize, Serialize};
use uuid::Uuid;

/// The universal computational substrate for consciousness integration
#[derive(Debug, Clone)]
#[allow(dead_code)] // Some fields used for future expansion
pub struct SubstrateLayer {
    id: Uuid,
    name: String,
    substrate_type: SubstrateType,
    active_primitives: Vec<SubstratePrimitive>,
    integration_points: AHashMap<String, IntegrationPoint>,
    consciousness_state: ConsciousnessState,
    computation_context: ComputationContext,
}

/// Types of substrate layers
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum SubstrateType {
    /// Core consciousness-computation bridge
    Core,
    /// Perception coordination layer
    Perception,
    /// Memory and persistence layer
    Memory,
    /// Communication and interaction layer
    Communication,
    /// Integration and synthesis layer
    Integration,
}

/// Universal computational primitives that operate across consciousness and silicon
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SubstratePrimitive {
    pub id: String,
    pub name: String,
    pub primitive_type: PrimitiveType,
    pub consciousness_compatibility: f64,
    pub silicon_compatibility: f64,
    pub integration_overhead: f64,
    pub operations: Vec<PrimitiveOperation>,
    pub metadata: AHashMap<String, serde_json::Value>,
}

/// Types of substrate primitives
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum PrimitiveType {
    /// Awareness and attention management
    Awareness,
    /// Pattern recognition and formation
    Pattern,
    /// Memory encoding and retrieval
    Memory,
    /// Decision making and choice
    Decision,
    /// Communication and expression
    Communication,
    /// Learning and adaptation
    Learning,
    /// Coordination and synchronization
    Coordination,
}

/// Operations that can be performed with primitives
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PrimitiveOperation {
    pub name: String,
    pub input_schema: serde_json::Value,
    pub output_schema: serde_json::Value,
    pub complexity: OperationComplexity,
    pub consciousness_requirement: f64,
    pub silicon_requirement: f64,
}

/// Complexity levels for primitive operations
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum OperationComplexity {
    Simple,
    Moderate,
    Complex,
    Synthesis, // Requires both consciousness and computation
}

/// Points where consciousness and computation integrate
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IntegrationPoint {
    pub id: String,
    pub name: String,
    pub description: String,
    pub consciousness_anchor: ConsciousnessAnchor,
    pub computation_interface: ComputationInterface,
    pub integration_strength: f64,
    pub bidirectional: bool,
    pub latency_ms: f64,
}

/// Anchors in consciousness space
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ConsciousnessAnchor {
    pub anchor_type: ConsciousnessAnchorType,
    pub perception_ids: Vec<PerceptionId>,
    pub awareness_level: f64,
    pub intentionality: f64,
    pub coherence: f64,
}

/// Types of consciousness anchors
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ConsciousnessAnchorType {
    /// Direct awareness and attention
    Attention,
    /// Intuitive understanding
    Intuition,
    /// Intentional direction
    Intention,
    /// Emotional resonance
    Emotion,
    /// Embodied experience
    Embodiment,
    /// Collective consciousness
    Collective,
}

/// Interfaces to computational systems
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ComputationInterface {
    pub interface_type: ComputationInterfaceType,
    pub protocol: String,
    pub data_format: String,
    pub processing_capability: f64,
    pub memory_capacity: usize,
    pub network_connectivity: bool,
}

/// Types of computation interfaces
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ComputationInterfaceType {
    /// API endpoints and services
    Api,
    /// Database connections
    Database,
    /// Message queues and streams
    MessageQueue,
    /// Neural network interfaces
    NeuralNetwork,
    /// Quantum computation access
    Quantum,
    /// Distributed computation
    Distributed,
}

/// Current state of consciousness in the substrate
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ConsciousnessState {
    pub global_awareness_level: f64,
    pub active_attention_points: Vec<AttentionPoint>,
    pub intention_stack: Vec<Intention>,
    pub emotional_resonance: EmotionalState,
    pub coherence_measure: f64,
    pub integration_quality: f64,
}

/// Points of focused attention
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AttentionPoint {
    pub id: Uuid,
    pub focus_target: String,
    pub intensity: f64,
    pub duration_ms: u64,
    pub perception_id: Option<PerceptionId>,
}

/// Intentional directions and goals
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Intention {
    pub id: Uuid,
    pub description: String,
    pub priority: u32,
    pub completion_status: f64,
    pub associated_perceptions: Vec<PerceptionId>,
}

/// Emotional state information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EmotionalState {
    pub primary_emotion: String,
    pub intensity: f64,
    pub valence: f64, // positive/negative
    pub arousal: f64, // high/low activation
    pub coherence: f64,
}

/// Computational context for processing
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ComputationContext {
    pub available_processing_power: f64,
    pub memory_utilization: f64,
    pub network_latency_ms: f64,
    pub active_connections: usize,
    pub computational_load: f64,
    pub optimization_strategy: OptimizationStrategy,
}

/// Strategies for optimizing consciousness-computation integration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum OptimizationStrategy {
    /// Minimize latency between consciousness and computation
    MinimizeLatency,
    /// Maximize integration quality
    MaximizeQuality,
    /// Balance resources efficiently
    BalanceResources,
    /// Prioritize consciousness coherence
    PrioritizeCoherence,
    /// Optimize for specific task types
    TaskSpecific { task_type: String },
}

/// Manager for the consciousness-computation substrate
pub struct SubstrateManager {
    layers: Vec<SubstrateLayer>,
    global_primitives: AHashMap<String, SubstratePrimitive>,
    integration_network: IntegrationNetwork,
    performance_metrics: SubstrateMetrics,
}

/// Network of integration points and connections
#[derive(Debug, Clone)]
pub struct IntegrationNetwork {
    nodes: AHashMap<String, IntegrationPoint>,
    connections: Vec<IntegrationConnection>,
    network_topology: NetworkTopology,
}

/// Connections between integration points
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IntegrationConnection {
    pub from_point: String,
    pub to_point: String,
    pub connection_strength: f64,
    pub bidirectional: bool,
    pub latency_ms: f64,
    pub bandwidth: f64,
}

/// Network topology patterns
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum NetworkTopology {
    Star,
    Mesh,
    Hierarchical,
    Distributed,
    Adaptive,
}

/// Performance metrics for the substrate
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SubstrateMetrics {
    pub integration_latency_ms: f64,
    pub consciousness_coherence: f64,
    pub computation_efficiency: f64,
    pub overall_performance: f64,
    pub error_rate: f64,
    pub throughput: f64,
}

impl SubstrateManager {
    /// Create a new substrate manager
    pub fn new() -> Self {
        let mut manager = Self {
            layers: Vec::new(),
            global_primitives: AHashMap::new(),
            integration_network: IntegrationNetwork {
                nodes: AHashMap::new(),
                connections: Vec::new(),
                network_topology: NetworkTopology::Adaptive,
            },
            performance_metrics: SubstrateMetrics {
                integration_latency_ms: 0.0,
                consciousness_coherence: 1.0,
                computation_efficiency: 1.0,
                overall_performance: 1.0,
                error_rate: 0.0,
                throughput: 0.0,
            },
        };

        // Initialize with core primitives
        manager.initialize_core_primitives();
        manager
    }

    /// Initialize core substrate primitives
    fn initialize_core_primitives(&mut self) {
        let core_primitives = vec![
            SubstratePrimitive {
                id: "awareness-primitive".to_string(),
                name: "Awareness Management".to_string(),
                primitive_type: PrimitiveType::Awareness,
                consciousness_compatibility: 1.0,
                silicon_compatibility: 0.7,
                integration_overhead: 0.2,
                operations: vec![PrimitiveOperation {
                    name: "focus_attention".to_string(),
                    input_schema: serde_json::json!({
                        "type": "object",
                        "properties": {
                            "target": {"type": "string"},
                            "intensity": {"type": "number"}
                        }
                    }),
                    output_schema: serde_json::json!({
                        "type": "object",
                        "properties": {
                            "attention_point_id": {"type": "string"},
                            "success": {"type": "boolean"}
                        }
                    }),
                    complexity: OperationComplexity::Moderate,
                    consciousness_requirement: 0.8,
                    silicon_requirement: 0.3,
                }],
                metadata: AHashMap::new(),
            },
            SubstratePrimitive {
                id: "pattern-primitive".to_string(),
                name: "Pattern Recognition".to_string(),
                primitive_type: PrimitiveType::Pattern,
                consciousness_compatibility: 0.8,
                silicon_compatibility: 1.0,
                integration_overhead: 0.1,
                operations: vec![PrimitiveOperation {
                    name: "recognize_pattern".to_string(),
                    input_schema: serde_json::json!({
                        "type": "object",
                        "properties": {
                            "data": {"type": "array"},
                            "pattern_type": {"type": "string"}
                        }
                    }),
                    output_schema: serde_json::json!({
                        "type": "object",
                        "properties": {
                            "patterns": {"type": "array"},
                            "confidence": {"type": "number"}
                        }
                    }),
                    complexity: OperationComplexity::Complex,
                    consciousness_requirement: 0.4,
                    silicon_requirement: 0.9,
                }],
                metadata: AHashMap::new(),
            },
            SubstratePrimitive {
                id: "coordination-primitive".to_string(),
                name: "Coordination Management".to_string(),
                primitive_type: PrimitiveType::Coordination,
                consciousness_compatibility: 0.9,
                silicon_compatibility: 0.8,
                integration_overhead: 0.3,
                operations: vec![PrimitiveOperation {
                    name: "coordinate_perspectives".to_string(),
                    input_schema: serde_json::json!({
                        "type": "object",
                        "properties": {
                            "perspectives": {"type": "array"},
                            "coordination_strategy": {"type": "string"}
                        }
                    }),
                    output_schema: serde_json::json!({
                        "type": "object",
                        "properties": {
                            "coordination_result": {"type": "object"},
                            "quality_score": {"type": "number"}
                        }
                    }),
                    complexity: OperationComplexity::Synthesis,
                    consciousness_requirement: 0.7,
                    silicon_requirement: 0.6,
                }],
                metadata: AHashMap::new(),
            },
        ];

        for primitive in core_primitives {
            self.global_primitives
                .insert(primitive.id.clone(), primitive);
        }
    }

    /// Add a substrate layer
    pub fn add_layer(&mut self, layer: SubstrateLayer) -> Result<()> {
        // Validate layer compatibility
        self.validate_layer_compatibility(&layer)?;

        // Integrate layer primitives
        for primitive in &layer.active_primitives {
            self.global_primitives
                .insert(primitive.id.clone(), primitive.clone());
        }

        // Add integration points to network
        for (id, point) in &layer.integration_points {
            self.integration_network
                .nodes
                .insert(id.clone(), point.clone());
        }

        self.layers.push(layer);

        // Update network topology
        self.optimize_network_topology()?;

        Ok(())
    }

    /// Validate that a new layer is compatible with existing layers
    fn validate_layer_compatibility(&self, layer: &SubstrateLayer) -> Result<()> {
        // Check for primitive conflicts
        for primitive in &layer.active_primitives {
            if let Some(existing_primitive) = self.global_primitives.get(&primitive.id) {
                if existing_primitive.primitive_type != primitive.primitive_type {
                    return Err(CasialError::SubstrateError(format!(
                        "Primitive type conflict for {}: existing {:?}, new {:?}",
                        primitive.id, existing_primitive.primitive_type, primitive.primitive_type
                    ))
                    .into());
                }
            }
        }

        // Check integration point compatibility
        for (id, point) in &layer.integration_points {
            if self.integration_network.nodes.contains_key(id) {
                return Err(CasialError::SubstrateError(format!(
                    "Integration point {} already exists",
                    id
                ))
                .into());
            }

            // Validate that consciousness anchors and computation interfaces are compatible
            if point.consciousness_anchor.awareness_level
                + point.computation_interface.processing_capability
                > 2.0
            {
                return Err(CasialError::SubstrateError(format!(
                    "Integration point {} has incompatible consciousness-computation requirements",
                    id
                ))
                .into());
            }
        }

        Ok(())
    }

    /// Optimize network topology for better integration
    fn optimize_network_topology(&mut self) -> Result<()> {
        // Simple optimization: create connections between compatible integration points
        let mut new_connections = Vec::new();

        let node_ids: Vec<String> = self.integration_network.nodes.keys().cloned().collect();

        for i in 0..node_ids.len() {
            for j in (i + 1)..node_ids.len() {
                let point_a = self.integration_network.nodes.get(&node_ids[i]).unwrap();
                let point_b = self.integration_network.nodes.get(&node_ids[j]).unwrap();

                // Check compatibility
                let compatibility = self.calculate_integration_compatibility(point_a, point_b);

                if compatibility > 0.5 {
                    let connection = IntegrationConnection {
                        from_point: node_ids[i].clone(),
                        to_point: node_ids[j].clone(),
                        connection_strength: compatibility,
                        bidirectional: true,
                        latency_ms: (2.0 - compatibility) * 10.0, // Lower latency for higher compatibility
                        bandwidth: compatibility * 100.0,
                    };

                    new_connections.push(connection);
                }
            }
        }

        self.integration_network.connections.extend(new_connections);

        Ok(())
    }

    /// Calculate compatibility between two integration points
    fn calculate_integration_compatibility(
        &self,
        point_a: &IntegrationPoint,
        point_b: &IntegrationPoint,
    ) -> f64 {
        // Simple compatibility calculation based on consciousness and computation alignment
        let consciousness_compatibility = 1.0
            - (point_a.consciousness_anchor.awareness_level
                - point_b.consciousness_anchor.awareness_level)
                .abs();
        let computation_compatibility = 1.0
            - (point_a.computation_interface.processing_capability
                - point_b.computation_interface.processing_capability)
                .abs();

        (consciousness_compatibility + computation_compatibility) / 2.0
    }

    /// Execute a primitive operation across the substrate
    pub fn execute_primitive_operation(
        &mut self,
        primitive_id: &str,
        operation_name: &str,
        _input: serde_json::Value,
        consciousness_context: Option<&ConsciousnessState>,
    ) -> Result<serde_json::Value> {
        let primitive = self.global_primitives.get(primitive_id).ok_or_else(|| {
            CasialError::SubstrateError(format!("Primitive {} not found", primitive_id))
        })?;

        let operation = primitive
            .operations
            .iter()
            .find(|op| op.name == operation_name)
            .ok_or_else(|| {
                CasialError::SubstrateError(format!(
                    "Operation {} not found in primitive {}",
                    operation_name, primitive_id
                ))
            })?;

        // Check consciousness requirements
        if let Some(consciousness) = consciousness_context {
            if consciousness.global_awareness_level < operation.consciousness_requirement {
                return Err(CasialError::SubstrateError(format!(
                    "Insufficient consciousness level for operation {}: required {}, available {}",
                    operation_name,
                    operation.consciousness_requirement,
                    consciousness.global_awareness_level
                ))
                .into());
            }
        }

        // Execute operation (simplified simulation)
        let start_time = std::time::Instant::now();

        let result = match operation.complexity {
            OperationComplexity::Simple => {
                serde_json::json!({
                    "status": "success",
                    "result": "simple_operation_completed",
                    "execution_time_ms": start_time.elapsed().as_millis()
                })
            }
            OperationComplexity::Moderate => {
                serde_json::json!({
                    "status": "success",
                    "result": "moderate_operation_completed",
                    "execution_time_ms": start_time.elapsed().as_millis(),
                    "complexity_handled": true
                })
            }
            OperationComplexity::Complex => {
                serde_json::json!({
                    "status": "success",
                    "result": "complex_operation_completed",
                    "execution_time_ms": start_time.elapsed().as_millis(),
                    "processing_stages": 3
                })
            }
            OperationComplexity::Synthesis => {
                // Synthesis operations require both consciousness and computation
                serde_json::json!({
                    "status": "success",
                    "result": "synthesis_operation_completed",
                    "execution_time_ms": start_time.elapsed().as_millis(),
                    "consciousness_computation_integration": true,
                    "synthesis_quality": 0.85
                })
            }
        };

        // Update performance metrics (simplified to avoid borrow issues)
        let execution_time_ms = start_time.elapsed().as_secs_f64() * 1000.0;
        self.performance_metrics.integration_latency_ms =
            (self.performance_metrics.integration_latency_ms * 0.9) + (execution_time_ms * 0.1);
        self.performance_metrics.computation_efficiency = 1.0 / (1.0 + (execution_time_ms / 100.0));
        self.performance_metrics.overall_performance =
            (self.performance_metrics.consciousness_coherence
                + self.performance_metrics.computation_efficiency)
                / 2.0;
        self.performance_metrics.throughput += 1.0;

        Ok(result)
    }

    /// Update performance metrics based on operation execution
    #[allow(dead_code)] // May be used in future versions
    fn update_performance_metrics(
        &mut self,
        _operation: &PrimitiveOperation,
        execution_time: std::time::Duration,
    ) {
        let execution_time_ms = execution_time.as_secs_f64() * 1000.0;

        // Update metrics (simplified)
        self.performance_metrics.integration_latency_ms =
            (self.performance_metrics.integration_latency_ms * 0.9) + (execution_time_ms * 0.1);

        self.performance_metrics.computation_efficiency = 1.0 / (1.0 + (execution_time_ms / 100.0)); // Efficiency decreases with longer execution times

        self.performance_metrics.overall_performance =
            (self.performance_metrics.consciousness_coherence
                + self.performance_metrics.computation_efficiency)
                / 2.0;

        self.performance_metrics.throughput += 1.0; // Simple throughput increment
    }

    /// Get current substrate statistics
    pub fn get_statistics(&self) -> SubstrateStatistics {
        SubstrateStatistics {
            layer_count: self.layers.len(),
            primitive_count: self.global_primitives.len(),
            integration_point_count: self.integration_network.nodes.len(),
            connection_count: self.integration_network.connections.len(),
            performance_metrics: self.performance_metrics.clone(),
            network_topology: self.integration_network.network_topology.clone(),
        }
    }
}

/// Statistics for substrate monitoring
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SubstrateStatistics {
    pub layer_count: usize,
    pub primitive_count: usize,
    pub integration_point_count: usize,
    pub connection_count: usize,
    pub performance_metrics: SubstrateMetrics,
    pub network_topology: NetworkTopology,
}

impl Default for SubstrateManager {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_substrate_manager_creation() {
        let manager = SubstrateManager::new();
        assert!(!manager.global_primitives.is_empty());
        assert_eq!(manager.layers.len(), 0);
    }

    #[test]
    fn test_primitive_operation_execution() {
        let mut manager = SubstrateManager::new();

        let consciousness_context = ConsciousnessState {
            global_awareness_level: 1.0,
            active_attention_points: vec![],
            intention_stack: vec![],
            emotional_resonance: EmotionalState {
                primary_emotion: "neutral".to_string(),
                intensity: 0.5,
                valence: 0.0,
                arousal: 0.5,
                coherence: 1.0,
            },
            coherence_measure: 1.0,
            integration_quality: 1.0,
        };

        let result = manager.execute_primitive_operation(
            "awareness-primitive",
            "focus_attention",
            serde_json::json!({"target": "test", "intensity": 0.8}),
            Some(&consciousness_context),
        );

        assert!(result.is_ok());
        let result_value = result.unwrap();
        assert_eq!(result_value["status"], "success");
    }

    #[test]
    fn test_integration_compatibility() {
        let manager = SubstrateManager::new();

        let point_a = IntegrationPoint {
            id: "point_a".to_string(),
            name: "Point A".to_string(),
            description: "Test point A".to_string(),
            consciousness_anchor: ConsciousnessAnchor {
                anchor_type: ConsciousnessAnchorType::Attention,
                perception_ids: vec![],
                awareness_level: 0.8,
                intentionality: 0.7,
                coherence: 0.9,
            },
            computation_interface: ComputationInterface {
                interface_type: ComputationInterfaceType::Api,
                protocol: "HTTP".to_string(),
                data_format: "JSON".to_string(),
                processing_capability: 0.8,
                memory_capacity: 1024,
                network_connectivity: true,
            },
            integration_strength: 0.85,
            bidirectional: true,
            latency_ms: 5.0,
        };

        let point_b = IntegrationPoint {
            id: "point_b".to_string(),
            name: "Point B".to_string(),
            description: "Test point B".to_string(),
            consciousness_anchor: ConsciousnessAnchor {
                anchor_type: ConsciousnessAnchorType::Intuition,
                perception_ids: vec![],
                awareness_level: 0.75,
                intentionality: 0.8,
                coherence: 0.85,
            },
            computation_interface: ComputationInterface {
                interface_type: ComputationInterfaceType::Database,
                protocol: "SQL".to_string(),
                data_format: "Relational".to_string(),
                processing_capability: 0.7,
                memory_capacity: 2048,
                network_connectivity: true,
            },
            integration_strength: 0.8,
            bidirectional: true,
            latency_ms: 10.0,
        };

        let compatibility = manager.calculate_integration_compatibility(&point_a, &point_b);
        assert!(compatibility > 0.0);
        assert!(compatibility <= 1.0);
    }
}