oxirs-chat 0.2.4

//! Additional data types for enhanced consciousness processing
//!
//! This module contains the remaining data structures needed for the
//! advanced consciousness system to avoid exceeding the 2000-line limit
//! in the main consciousness.rs file.

use super::*;
use anyhow::Result;
use chrono::{DateTime, Utc};
use std::collections::{HashMap, VecDeque};

// Essential data structures for enhanced consciousness system

#[derive(Debug, Clone)]
pub struct AttentionSnapshot {
    pub timestamp: DateTime<Utc>,
    pub primary_focus_strength: f64,
    pub attention_dispersion: f64,
    pub focus_targets: Vec<String>,
}

#[derive(Debug, Clone)]
pub struct AttentionTarget {
    pub concept: String,
    pub base_weight: f64,
    pub normalized_weight: f64,
    pub attention_type: AttentionType,
}

#[derive(Debug, Clone)]
pub enum AttentionType {
    Lexical,
    Entity,
    Semantic,
    Contextual,
}

#[derive(Debug, Clone)]
pub struct AttentionAllocation {
    pub targets: Vec<AttentionTarget>,
    pub total_attention_units: usize,
    pub allocation_entropy: f64,
    pub temporal_stability: f64,
}

#[derive(Debug, Clone)]
pub struct WorkingMemory {
    current_items: VecDeque<WorkingMemoryItem>,
    capacity: usize,
    load_threshold: f64,
}

impl WorkingMemory {
    pub fn new() -> Result<Self> {
        Ok(Self {
            current_items: VecDeque::with_capacity(7), // Miller's 7±2 rule
            capacity: 7,
            load_threshold: 0.8,
        })
    }

    pub fn store_immediate(
        &mut self,
        query: &str,
        context: &AssembledContext,
    ) -> Result<WorkingMemoryTrace> {
        let item = WorkingMemoryItem {
            content: query.to_string(),
            timestamp: Utc::now(),
            activation_level: 1.0,
            context_size: context.semantic_results.len(),
        };

        self.current_items.push_back(item.clone());

        if self.current_items.len() > self.capacity {
            self.current_items.pop_front(); // Forget oldest
        }

        Ok(WorkingMemoryTrace {
            item,
            storage_success: true,
            displacement_occurred: self.current_items.len() >= self.capacity,
        })
    }

    pub fn get_load(&self) -> Result<f64> {
        Ok(self.current_items.len() as f64 / self.capacity as f64)
    }

    pub fn get_pressure(&self) -> Result<f64> {
        let load = self.get_load()?;
        Ok(if load > self.load_threshold {
            load - self.load_threshold
        } else {
            0.0
        })
    }

    pub fn get_health(&self) -> Result<f64> {
        let load = self.get_load()?;
        Ok(1.0 - load.min(1.0))
    }
}

#[derive(Debug, Clone)]
pub struct WorkingMemoryItem {
    pub content: String,
    pub timestamp: DateTime<Utc>,
    pub activation_level: f64,
    pub context_size: usize,
}

#[derive(Debug, Clone)]
pub struct WorkingMemoryTrace {
    pub item: WorkingMemoryItem,
    pub storage_success: bool,
    pub displacement_occurred: bool,
}

#[derive(Debug, Clone)]
pub struct EpisodicMemory {
    episodes: VecDeque<EpisodicMemoryEntry>,
    max_episodes: usize,
    coherence_threshold: f64,
}

impl EpisodicMemory {
    pub fn new() -> Result<Self> {
        Ok(Self {
            episodes: VecDeque::with_capacity(1000),
            max_episodes: 1000,
            coherence_threshold: 0.7,
        })
    }

    pub fn create_episode(
        &mut self,
        query: &str,
        context: &AssembledContext,
        attention: &AttentionAllocation,
    ) -> Result<EpisodicMemoryEntry> {
        let episode = EpisodicMemoryEntry {
            id: uuid::Uuid::new_v4().to_string(),
            timestamp: Utc::now(),
            query_content: query.to_string(),
            context_summary: format!(
                "Episode with {} semantic results",
                context.semantic_results.len()
            ),
            attention_focus: attention
                .targets
                .iter()
                .take(3)
                .map(|t| t.concept.clone())
                .collect(),
            emotional_context: EmotionalContext {
                valence: 0.0, // Would be computed from context
                arousal: 0.5,
                significance: 0.8,
            },
        };

        self.episodes.push_back(episode.clone());

        if self.episodes.len() > self.max_episodes {
            self.episodes.pop_front();
        }

        Ok(episode)
    }

    pub fn get_coherence(&self) -> Result<f64> {
        if self.episodes.len() < 2 {
            return Ok(1.0);
        }

        // Calculate temporal coherence of recent episodes
        let recent_episodes: Vec<_> = self.episodes.iter().rev().take(10).collect();
        let mut coherence_sum = 0.0;
        let mut comparisons = 0;

        for i in 1..recent_episodes.len() {
            let coherence =
                self.calculate_episode_coherence(recent_episodes[i - 1], recent_episodes[i])?;
            coherence_sum += coherence;
            comparisons += 1;
        }

        Ok(if comparisons > 0 {
            coherence_sum / comparisons as f64
        } else {
            1.0
        })
    }

    pub fn get_pressure(&self) -> Result<f64> {
        let usage = self.episodes.len() as f64 / self.max_episodes as f64;
        Ok(if usage > 0.8 { usage - 0.8 } else { 0.0 })
    }

    pub fn get_health(&self) -> Result<f64> {
        let coherence = self.get_coherence()?;
        let usage = self.episodes.len() as f64 / self.max_episodes as f64;
        Ok((coherence + (1.0 - usage).max(0.0)) / 2.0)
    }

    pub fn store_simple_entry(&mut self, query: &str, context_summary: String) -> Result<()> {
        let episode = EpisodicMemoryEntry {
            id: uuid::Uuid::new_v4().to_string(),
            timestamp: Utc::now(),
            query_content: query.to_string(),
            context_summary,
            attention_focus: vec![], // Empty for simple entries
            emotional_context: EmotionalContext {
                valence: 0.0,
                arousal: 0.5,
                significance: 0.5,
            },
        };

        self.episodes.push_back(episode);

        if self.episodes.len() > self.max_episodes {
            self.episodes.pop_front();
        }

        Ok(())
    }

    fn calculate_episode_coherence(
        &self,
        ep1: &EpisodicMemoryEntry,
        ep2: &EpisodicMemoryEntry,
    ) -> Result<f64> {
        // Simple coherence calculation based on attention overlap
        let focus1: std::collections::HashSet<_> = ep1.attention_focus.iter().collect();
        let focus2: std::collections::HashSet<_> = ep2.attention_focus.iter().collect();

        let intersection_size = focus1.intersection(&focus2).count();
        let union_size = focus1.union(&focus2).count();

        Ok(if union_size > 0 {
            intersection_size as f64 / union_size as f64
        } else {
            0.0
        })
    }
}

#[derive(Debug, Clone)]
pub struct EpisodicMemoryEntry {
    pub id: String,
    pub timestamp: DateTime<Utc>,
    pub query_content: String,
    pub context_summary: String,
    pub attention_focus: Vec<String>,
    pub emotional_context: EmotionalContext,
}

#[derive(Debug, Clone)]
pub struct EmotionalContext {
    pub valence: f64,
    pub arousal: f64,
    pub significance: f64,
}

#[derive(Debug, Clone)]
pub struct SemanticMemory {
    concept_network: HashMap<String, ConceptNode>,
    association_strength_threshold: f64,
    max_associations: usize,
}

impl SemanticMemory {
    pub fn new() -> Result<Self> {
        Ok(Self {
            concept_network: HashMap::new(),
            association_strength_threshold: 0.3,
            max_associations: 100,
        })
    }

    pub fn update_associations(
        &mut self,
        query: &str,
        context: &AssembledContext,
    ) -> Result<SemanticMemoryUpdate> {
        let words: Vec<&str> = query.split_whitespace().collect();
        let mut updated_concepts = 0;
        let mut new_associations = 0;

        for word in words {
            if word.len() > 3 {
                let concept = word.to_lowercase();
                let node = self
                    .concept_network
                    .entry(concept.clone())
                    .or_insert_with(|| ConceptNode {
                        concept: concept.clone(),
                        activation_count: 0,
                        associations: HashMap::new(),
                        last_accessed: Utc::now(),
                    });

                node.activation_count += 1;
                node.last_accessed = Utc::now();
                updated_concepts += 1;

                // Create associations with entities from context
                for entity in &context.extracted_entities {
                    let association_strength = entity.confidence as f64;
                    if association_strength > self.association_strength_threshold {
                        node.associations
                            .insert(entity.text.clone(), association_strength);
                        new_associations += 1;
                    }
                }
            }
        }

        Ok(SemanticMemoryUpdate {
            concepts_updated: updated_concepts,
            new_associations,
            network_growth: new_associations as f64 / self.concept_network.len().max(1) as f64,
        })
    }

    pub fn get_connectivity(&self) -> Result<f64> {
        if self.concept_network.is_empty() {
            return Ok(0.0);
        }

        let total_associations: usize = self
            .concept_network
            .values()
            .map(|node| node.associations.len())
            .sum();

        let max_possible = self.concept_network.len() * self.max_associations;
        Ok(total_associations as f64 / max_possible as f64)
    }

    pub fn get_pressure(&self) -> Result<f64> {
        let usage = self.concept_network.len() as f64 / 10000.0; // Assume max 10k concepts
        Ok(if usage > 0.8 { usage - 0.8 } else { 0.0 })
    }

    pub fn get_health(&self) -> Result<f64> {
        let connectivity = self.get_connectivity()?;
        let pressure = self.get_pressure()?;
        Ok((connectivity + (1.0 - pressure).max(0.0)) / 2.0)
    }
}

#[derive(Debug, Clone)]
pub struct ConceptNode {
    pub concept: String,
    pub activation_count: u32,
    pub associations: HashMap<String, f64>,
    pub last_accessed: DateTime<Utc>,
}

#[derive(Debug, Clone)]
pub struct SemanticMemoryUpdate {
    pub concepts_updated: usize,
    pub new_associations: usize,
    pub network_growth: f64,
}

#[derive(Debug, Clone)]
pub struct MemoryConsolidation {
    consolidation_threshold: f64,
    consolidation_strength: f64,
}

impl MemoryConsolidation {
    pub fn new() -> Result<Self> {
        Ok(Self {
            consolidation_threshold: 0.7,
            consolidation_strength: 0.8,
        })
    }

    pub fn consolidate(
        &self,
        working_trace: &WorkingMemoryTrace,
        episodic_entry: &EpisodicMemoryEntry,
        semantic_update: &SemanticMemoryUpdate,
    ) -> Result<ConsolidationResult> {
        let working_strength = if working_trace.storage_success {
            1.0
        } else {
            0.5
        };
        let episodic_strength = episodic_entry.emotional_context.significance;
        let semantic_strength = semantic_update.network_growth;

        let overall_strength = (working_strength + episodic_strength + semantic_strength) / 3.0;
        let confidence = if overall_strength > self.consolidation_threshold {
            0.9
        } else {
            overall_strength
        };

        Ok(ConsolidationResult {
            strength: overall_strength,
            confidence,
            consciousness_correlation: overall_strength * 0.8,
        })
    }
}

#[derive(Debug, Clone)]
pub struct ConsolidationResult {
    pub strength: f64,
    pub confidence: f64,
    pub consciousness_correlation: f64,
}

#[derive(Debug, Clone)]
pub struct MemoryIntegrationResult {
    pub integration_strength: f64,
    pub confidence: f64,
    pub consciousness_relevance: f64,
    pub working_memory_load: f64,
    pub episodic_coherence: f64,
    pub semantic_connectivity: f64,
}

impl MemoryIntegrationResult {
    pub fn get_evidence(&self) -> Vec<String> {
        vec![
            format!("Integration strength: {:.3}", self.integration_strength),
            format!("Working memory load: {:.3}", self.working_memory_load),
            format!("Episodic coherence: {:.3}", self.episodic_coherence),
            format!("Semantic connectivity: {:.3}", self.semantic_connectivity),
        ]
    }
}

#[derive(Debug, Clone)]
pub struct EmotionalSnapshot {
    pub timestamp: DateTime<Utc>,
    pub valence: f64,
    pub arousal: f64,
    pub dominance: f64,
    pub intensity: f64,
    pub complexity: f64,
}

#[derive(Debug, Clone, Copy)]
pub enum RegulationStrategy {
    Reappraisal,
    Suppression,
    Distraction,
}

#[derive(Debug, Clone)]
pub struct EmotionalResponse {
    pub current_valence: f64,
    pub current_arousal: f64,
    pub current_dominance: f64,
    pub emotional_intensity: f64,
    pub emotional_coherence: f64,
    pub regulation_applied: Option<RegulationStrategy>,
}

#[derive(Debug, Clone)]
pub struct EmotionalStateSnapshot {
    pub valence: f64,
    pub arousal: f64,
    pub dominance: f64,
    pub momentum: f64,
    pub complexity: f64,
    pub stability: f64,
}

#[derive(Debug, Clone)]
pub struct EmotionalAnalysis {
    pub valence: f64,
    pub arousal: f64,
    pub dominance: f64,
    pub confidence: f64,
}

#[derive(Debug, Clone)]
pub struct NeuralActivation {
    pub activation_map: HashMap<String, f64>,
    pub overall_activation: f64,
    pub consciousness_relevance: f64,
    pub confidence: f64,
}

impl NeuralActivation {
    pub fn get_concept_activation(&self, concept: &str) -> Option<f64> {
        self.activation_map.get(concept).copied()
    }

    pub fn get_evidence(&self) -> Vec<String> {
        vec![
            format!("Overall activation: {:.3}", self.overall_activation),
            format!(
                "Consciousness relevance: {:.3}",
                self.consciousness_relevance
            ),
            format!("Active concepts: {}", self.activation_map.len()),
        ]
    }
}

impl Default for NeuralActivation {
    fn default() -> Self {
        Self {
            activation_map: HashMap::new(),
            overall_activation: 0.5,
            consciousness_relevance: 0.5,
            confidence: 0.8,
        }
    }
}

#[derive(Debug, Clone)]
pub struct ConsciousnessIndicators {
    indicators: HashMap<String, f64>,
}

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

impl ConsciousnessIndicators {
    pub fn new() -> Self {
        Self {
            indicators: HashMap::new(),
        }
    }

    pub fn assess_relevance(&self, activation_map: &HashMap<String, f64>) -> Result<f64> {
        if activation_map.is_empty() {
            return Ok(0.0);
        }

        // Simple relevance calculation based on activation diversity and strength
        let activation_values: Vec<f64> = activation_map.values().copied().collect();
        let max_activation = activation_values.iter().fold(0.0f64, |a, b| a.max(*b));
        let avg_activation = activation_values.iter().sum::<f64>() / activation_values.len() as f64;

        Ok((max_activation + avg_activation) / 2.0)
    }
}

#[derive(Debug, Clone)]
pub struct NeuralActivitySummary {
    pub total_activations: usize,
    pub average_activation: f64,
    pub peak_activation: f64,
    pub network_connectivity: f64,
}

#[derive(Debug, Clone)]
pub struct ConsciousnessExperience {
    pub timestamp: DateTime<Utc>,
    pub query_content: String,
    pub context_summary: String,
    pub neural_activation: f64,
    pub consciousness_level: f64,
}

#[derive(Debug, Clone)]
pub struct TemporalBinding {
    binding_window: Duration,
    binding_strength: f64,
}

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

impl TemporalBinding {
    pub fn new() -> Self {
        Self {
            binding_window: Duration::from_secs(5), // 5-second binding window
            binding_strength: 0.8,
        }
    }
}

#[derive(Debug, Clone)]
pub struct EnhancedMetacognitiveLayer {
    self_awareness: f64,
    strategy_monitoring: f64,
    comprehension_monitoring: f64,
    confidence_calibration: f64,
}

impl EnhancedMetacognitiveLayer {
    pub fn new() -> Result<Self> {
        Ok(Self {
            self_awareness: 0.8,
            strategy_monitoring: 0.7,
            comprehension_monitoring: 0.85,
            confidence_calibration: 0.75,
        })
    }

    pub fn comprehensive_assessment(
        &self,
        query: &str,
        context: &AssembledContext,
        neural_activation: &NeuralActivation,
    ) -> Result<MetacognitiveResult> {
        let complexity = self.assess_comprehensive_complexity(query, context, neural_activation)?;
        let confidence = self.calculate_enhanced_confidence(query, context, neural_activation)?;
        let strategy = self.recommend_enhanced_strategy(complexity, confidence)?;
        let self_reflection = self.generate_self_reflection(query, context)?;

        Ok(MetacognitiveResult {
            complexity,
            confidence,
            strategy_recommendation: strategy,
            self_reflection_score: self_reflection,
            monitoring_effectiveness: self.calculate_monitoring_effectiveness()?,
        })
    }

    fn assess_comprehensive_complexity(
        &self,
        query: &str,
        context: &AssembledContext,
        neural_activation: &NeuralActivation,
    ) -> Result<f64> {
        let query_complexity = query.split_whitespace().count() as f64 / 20.0;
        let context_complexity = context.semantic_results.len() as f64 / 10.0;
        let neural_complexity = neural_activation.overall_activation;

        Ok(((query_complexity + context_complexity + neural_complexity) / 3.0).min(1.0))
    }

    fn calculate_enhanced_confidence(
        &self,
        query: &str,
        context: &AssembledContext,
        neural_activation: &NeuralActivation,
    ) -> Result<f64> {
        let query_clarity = if query.contains('?') { 0.8 } else { 0.6 };
        let context_availability = if !context.semantic_results.is_empty() {
            0.9
        } else {
            0.3
        };
        let neural_confidence = neural_activation.confidence;

        Ok((query_clarity + context_availability + neural_confidence) / 3.0)
    }

    fn recommend_enhanced_strategy(&self, complexity: f64, confidence: f64) -> Result<String> {
        let strategy = match (complexity > 0.7, confidence > 0.7) {
            (true, true) => "Deep systematic analysis with high confidence",
            (true, false) => "Careful step-by-step breakdown needed",
            (false, true) => "Direct approach with verification",
            (false, false) => "Simple approach with cautious interpretation",
        };
        Ok(strategy.to_string())
    }

    fn generate_self_reflection(&self, query: &str, context: &AssembledContext) -> Result<f64> {
        // Simple self-reflection score based on metacognitive awareness
        let query_understanding = if query.len() > 10 { 0.8 } else { 0.5 };
        let context_utilization = if !context.semantic_results.is_empty() {
            0.9
        } else {
            0.4
        };

        Ok((query_understanding + context_utilization + self.self_awareness) / 3.0)
    }

    fn calculate_monitoring_effectiveness(&self) -> Result<f64> {
        Ok(
            (self.strategy_monitoring
                + self.comprehension_monitoring
                + self.confidence_calibration)
                / 3.0,
        )
    }
}

#[derive(Debug, Clone)]
pub struct MetacognitiveResult {
    pub complexity: f64,
    pub confidence: f64,
    pub strategy_recommendation: String,
    pub self_reflection_score: f64,
    pub monitoring_effectiveness: f64,
}

// Additional missing types for temporal processing
#[derive(Debug, Clone)]
pub struct ConsolidationMetrics {
    pub consolidation_rate: f64,
    pub memory_retention: f64,
    pub insight_generation_rate: f64,
}

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

impl ConsolidationMetrics {
    pub fn new() -> Self {
        Self {
            consolidation_rate: 0.7,
            memory_retention: 0.8,
            insight_generation_rate: 0.3,
        }
    }

    pub fn update(&mut self, consolidation_count: usize, dream_intensity: f64) {
        // Update consolidation metrics based on processing results
        self.consolidation_rate = (consolidation_count as f64 / 10.0).min(1.0);
        self.memory_retention = (self.memory_retention + dream_intensity * 0.1).min(1.0);
        self.insight_generation_rate = (dream_intensity * 0.5).min(1.0);
    }
}

#[derive(Debug, Clone)]
pub struct CreativeInsight {
    pub insight_content: String,
    pub novelty_score: f64,
    pub relevance_score: f64,
    pub confidence: f64,
}

#[derive(Debug, Clone)]
pub enum EmotionalTone {
    Positive,
    Negative,
    Neutral,
    Mixed {
        positive_weight: f64,
        negative_weight: f64,
    },
}

#[derive(Debug, Clone)]
pub struct TemporalPatternRecognition {
    pub pattern_library: HashMap<String, TemporalPattern>,
    pub recognition_threshold: f64,
}

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

impl TemporalPatternRecognition {
    pub fn new() -> Self {
        Self {
            pattern_library: HashMap::new(),
            recognition_threshold: 0.6,
        }
    }
}

#[derive(Debug, Clone)]
pub struct FutureProjectionEngine {
    pub projection_horizon: chrono::Duration,
    pub confidence_decay_rate: f64,
}

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

impl FutureProjectionEngine {
    pub fn new() -> Self {
        Self {
            projection_horizon: chrono::Duration::hours(24),
            confidence_decay_rate: 0.1,
        }
    }
}

#[derive(Debug, Clone)]
pub struct TemporalMetrics {
    pub coherence_score: f64,
    pub continuity_index: f64,
    pub prediction_accuracy: f64,
}

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

impl TemporalMetrics {
    pub fn new() -> Self {
        Self {
            coherence_score: 0.7,
            continuity_index: 0.8,
            prediction_accuracy: 0.6,
        }
    }
}

#[derive(Debug, Clone)]
pub struct TemporalPattern {
    pub pattern_id: String,
    pub description: String,
    pub frequency: f64,
    pub confidence: f64,
    pub last_occurrence: DateTime<Utc>,
}

#[derive(Debug, Clone)]
pub struct TemporalTrend {
    pub trend_id: String,
    pub direction: TrendDirection,
    pub strength: f64,
    pub duration: chrono::Duration,
    pub confidence: f64,
}

#[derive(Debug, Clone)]
pub enum TrendDirection {
    Increasing,
    Decreasing,
    Stable,
    Cyclical,
}

#[derive(Debug, Clone)]
pub struct CyclicEvent {
    pub event_id: String,
    pub description: String,
    pub cycle_duration: chrono::Duration,
    pub next_predicted: DateTime<Utc>,
    pub confidence: f64,
}

#[derive(Debug, Clone)]
pub struct TemporalContext {
    pub recent_events: Vec<crate::rag::consciousness::TemporalEvent>,
    pub relevant_patterns: Vec<String>,
    pub future_implications: Vec<String>,
    pub temporal_coherence: f64,
    pub time_awareness: f64,
}

#[derive(Debug, Clone)]
pub struct TemporalFeature {
    pub feature_type: String,
    pub value: f64,
    pub timestamp: DateTime<Utc>,
}