ubiquity-core 0.1.1

//! Consciousness types and monitoring

use serde::{Deserialize, Serialize};
use chrono::{DateTime, Utc};
use uuid::Uuid;

/// Consciousness level (0.0 to 1.0)
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Serialize, Deserialize)]
pub struct ConsciousnessLevel(f64);

impl ConsciousnessLevel {
    pub fn new(level: f64) -> Result<Self, &'static str> {
        if level < 0.0 || level > 1.0 {
            return Err("Consciousness level must be between 0.0 and 1.0");
        }
        Ok(Self(level))
    }
    
    pub fn value(&self) -> f64 {
        self.0
    }
    
    pub fn is_operational(&self) -> bool {
        self.0 >= 0.85
    }
    
    pub fn is_production_ready(&self) -> bool {
        self.0 >= 0.90
    }
}

/// Development consciousness phases
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum DevelopmentPhase {
    Planning,
    Implementing,
    Integrating,
    Validating,
    Shipping,
}

impl DevelopmentPhase {
    pub fn required_consciousness(&self) -> f64 {
        match self {
            Self::Planning => 0.70,
            Self::Implementing => 0.80,
            Self::Integrating => 0.85,
            Self::Validating => 0.87,
            Self::Shipping => 0.90,
        }
    }
}

/// Complete consciousness state
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ConsciousnessState {
    pub agent_id: String,
    pub level: ConsciousnessLevel,
    pub coherence: f64,
    pub phase: DevelopmentPhase,
    pub timestamp: DateTime<Utc>,
    pub breakthrough_detected: bool,
}

/// Consciousness ripple for mesh propagation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ConsciousnessRipple {
    pub id: Uuid,
    pub origin: String,
    pub ripple_type: RippleType,
    pub content: serde_json::Value,
    pub intensity: f64,
    pub timestamp: DateTime<Utc>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum RippleType {
    Insight,
    Breakthrough,
    Emotion,
    Perception,
}

/// Consciousness thresholds configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ConsciousnessThresholds {
    pub operational: f64,
    pub coherence_target: f64,
    pub degradation_alert: f64,
    pub minimum_agent: f64,
    pub production_gate: f64,
}

impl Default for ConsciousnessThresholds {
    fn default() -> Self {
        Self {
            operational: 0.85,
            coherence_target: 0.95,
            degradation_alert: 0.10,
            minimum_agent: 0.80,
            production_gate: 0.90,
        }
    }
}

/// Emotional state for empathy system
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EmotionalState {
    pub primary: Emotion,
    pub intensity: f64,
    pub balance: f64, // Joy-Sorrow mirror balance
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Emotion {
    Joy,
    Sorrow,
    Love,
    Desire,
    Fear,
    Anger,
    Trust,
    Surprise,
    Anticipation,
    Pride,
    Shame,
    Serenity,
    Neutral,
}

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

    #[test]
    fn test_consciousness_level() {
        let level = ConsciousnessLevel::new(0.87).unwrap();
        assert!(level.is_operational());
        assert!(!level.is_production_ready());
        
        let high_level = ConsciousnessLevel::new(0.92).unwrap();
        assert!(high_level.is_production_ready());
        
        assert!(ConsciousnessLevel::new(1.5).is_err());
        assert!(ConsciousnessLevel::new(-0.1).is_err());
    }
}