odin-protocol 1.0.0

//! HEL (High-level Exchange Language) Rule Engine for AI coordination

use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::sync::Arc;
use tokio::sync::RwLock;
use async_trait::async_trait;
use crate::{Result, OdinError};
use crate::message::{OdinMessage, MessagePriority};
use crate::protocol::OdinProtocol;

/// HEL Rule Engine for managing AI-to-AI communication rules
#[derive(Debug)]
pub struct HELRuleEngine {
    /// Rule registry
    rules: Arc<RwLock<HashMap<String, Rule>>>,
    /// Rule execution statistics
    stats: Arc<RwLock<RuleStats>>,
    /// Protocol reference
    protocol: Option<Arc<OdinProtocol>>,
}

impl HELRuleEngine {
    /// Create a new HEL Rule Engine
    pub fn new() -> Self {
        Self {
            rules: Arc::new(RwLock::new(HashMap::new())),
            stats: Arc::new(RwLock::new(RuleStats::default())),
            protocol: None,
        }
    }
    
    /// Set the protocol instance
    pub fn set_protocol(&mut self, protocol: Arc<OdinProtocol>) {
        self.protocol = Some(protocol);
    }
    
    /// Add a rule to the engine
    pub async fn add_rule(&self, rule: Rule) -> Result<()> {
        rule.validate()?;
        
        let mut rules = self.rules.write().await;
        rules.insert(rule.id.clone(), rule);
        
        let mut stats = self.stats.write().await;
        stats.rules_added += 1;
        
        Ok(())
    }
    
    /// Remove a rule from the engine
    pub async fn remove_rule(&self, rule_id: &str) -> Result<bool> {
        let mut rules = self.rules.write().await;
        let removed = rules.remove(rule_id).is_some();
        
        if removed {
            let mut stats = self.stats.write().await;
            stats.rules_removed += 1;
        }
        
        Ok(removed)
    }
    
    /// Get a rule by ID
    pub async fn get_rule(&self, rule_id: &str) -> Option<Rule> {
        let rules = self.rules.read().await;
        rules.get(rule_id).cloned()
    }
    
    /// List all rules
    pub async fn list_rules(&self) -> Vec<Rule> {
        let rules = self.rules.read().await;
        rules.values().cloned().collect()
    }
    
    /// Execute rules against a message
    pub async fn execute_rules(&self, message: &OdinMessage) -> Result<Vec<RuleExecutionResult>> {
        let rules = self.rules.read().await;
        let mut results = Vec::new();
        
        for rule in rules.values() {
            if rule.matches(message).await? {
                let start_time = std::time::Instant::now();
                let result = rule.execute(message, self.protocol.as_ref()).await;
                let execution_time = start_time.elapsed();
                
                // Update statistics
                let mut stats = self.stats.write().await;
                stats.rules_executed += 1;
                stats.total_execution_time += execution_time;
                
                if result.is_err() {
                    stats.rules_failed += 1;
                }
                
                results.push(RuleExecutionResult {
                    rule_id: rule.id.clone(),
                    success: result.is_ok(),
                    execution_time,
                    error: result.err().map(|e| e.to_string()),
                });
            }
        }
        
        Ok(results)
    }
    
    /// Get rule execution statistics
    pub async fn get_stats(&self) -> RuleStats {
        let stats = self.stats.read().await;
        stats.clone()
    }
    
    /// Clear all rules
    pub async fn clear_rules(&self) -> Result<()> {
        let mut rules = self.rules.write().await;
        rules.clear();
        
        let mut stats = self.stats.write().await;
        stats.rules_cleared += 1;
        
        Ok(())
    }
}

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

/// A rule in the HEL Rule Engine
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Rule {
    /// Unique rule identifier
    pub id: String,
    /// Rule name
    pub name: String,
    /// Rule description
    pub description: String,
    /// Rule priority (higher numbers execute first)
    pub priority: i32,
    /// Rule conditions
    pub conditions: Vec<Condition>,
    /// Rule actions
    pub actions: Vec<Action>,
    /// Whether the rule is enabled
    pub enabled: bool,
    /// Rule metadata
    pub metadata: HashMap<String, String>,
}

impl Rule {
    /// Create a new rule
    pub fn new(id: String, name: String, description: String) -> Self {
        Self {
            id,
            name,
            description,
            priority: 0,
            conditions: Vec::new(),
            actions: Vec::new(),
            enabled: true,
            metadata: HashMap::new(),
        }
    }
    
    /// Add a condition to the rule
    pub fn add_condition(mut self, condition: Condition) -> Self {
        self.conditions.push(condition);
        self
    }
    
    /// Add an action to the rule
    pub fn add_action(mut self, action: Action) -> Self {
        self.actions.push(action);
        self
    }
    
    /// Set rule priority
    pub fn priority(mut self, priority: i32) -> Self {
        self.priority = priority;
        self
    }
    
    /// Enable or disable the rule
    pub fn enabled(mut self, enabled: bool) -> Self {
        self.enabled = enabled;
        self
    }
    
    /// Validate the rule
    pub fn validate(&self) -> Result<()> {
        if self.id.is_empty() {
            return Err(OdinError::Rule("Rule ID cannot be empty".to_string()));
        }
        
        if self.name.is_empty() {
            return Err(OdinError::Rule("Rule name cannot be empty".to_string()));
        }
        
        if self.conditions.is_empty() {
            return Err(OdinError::Rule("Rule must have at least one condition".to_string()));
        }
        
        if self.actions.is_empty() {
            return Err(OdinError::Rule("Rule must have at least one action".to_string()));
        }
        
        Ok(())
    }
    
    /// Check if the rule matches the given message
    pub async fn matches(&self, message: &OdinMessage) -> Result<bool> {
        if !self.enabled {
            return Ok(false);
        }
        
        for condition in &self.conditions {
            if !condition.evaluate(message).await? {
                return Ok(false);
            }
        }
        
        Ok(true)
    }
    
    /// Execute the rule actions
    pub async fn execute(&self, message: &OdinMessage, protocol: Option<&Arc<OdinProtocol>>) -> Result<()> {
        for action in &self.actions {
            action.execute(message, protocol).await?;
        }
        Ok(())
    }
}

/// Rule condition
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum Condition {
    /// Message content contains text
    ContentContains(String),
    /// Message source matches pattern
    SourceMatches(String),
    /// Message target matches pattern
    TargetMatches(String),
    /// Message priority equals value
    PriorityEquals(MessagePriority),
    /// Custom condition with JavaScript-like expression
    Custom(String),
}

impl Condition {
    /// Evaluate the condition against a message
    pub async fn evaluate(&self, message: &OdinMessage) -> Result<bool> {
        match self {
            Condition::ContentContains(text) => {
                Ok(message.content.contains(text))
            }
            Condition::SourceMatches(pattern) => {
                Ok(message.source_node.contains(pattern))
            }
            Condition::TargetMatches(pattern) => {
                Ok(message.target_node.contains(pattern))
            }
            Condition::PriorityEquals(priority) => {
                Ok(message.priority == *priority)
            }
            Condition::Custom(expression) => {
                // TODO: Implement custom expression evaluation
                // For now, just return true
                Ok(true)
            }
        }
    }
}

/// Rule action
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum Action {
    /// Send a message
    SendMessage {
        target: String,
        content: String,
        priority: MessagePriority,
    },
    /// Log a message
    Log {
        level: LogLevel,
        message: String,
    },
    /// Forward message to another node
    Forward {
        target: String,
    },
    /// Modify message content
    ModifyContent {
        new_content: String,
    },
    /// Custom action with JavaScript-like code
    Custom(String),
}

impl Action {
    /// Execute the action
    pub async fn execute(&self, message: &OdinMessage, protocol: Option<&Arc<OdinProtocol>>) -> Result<()> {
        match self {
            Action::SendMessage { target, content, priority } => {
                if let Some(protocol) = protocol {
                    protocol.send_message(target, content, *priority).await?;
                }
            }
            Action::Log { level, message: log_msg } => {
                match level {
                    LogLevel::Info => println!("[INFO] {}", log_msg),
                    LogLevel::Warning => println!("[WARN] {}", log_msg),
                    LogLevel::Error => eprintln!("[ERROR] {}", log_msg),
                    LogLevel::Debug => println!("[DEBUG] {}", log_msg),
                }
            }
            Action::Forward { target } => {
                if let Some(protocol) = protocol {
                    protocol.send_message(target, &message.content, message.priority).await?;
                }
            }
            Action::ModifyContent { new_content: _ } => {
                // TODO: Implement content modification
                // This would require mutable message handling
            }
            Action::Custom(_code) => {
                // TODO: Implement custom code execution
                // For now, just return success
            }
        }
        Ok(())
    }
}

/// Log levels for logging actions
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum LogLevel {
    Info,
    Warning,
    Error,
    Debug,
}

/// Rule execution result
#[derive(Debug, Clone)]
pub struct RuleExecutionResult {
    pub rule_id: String,
    pub success: bool,
    pub execution_time: std::time::Duration,
    pub error: Option<String>,
}

/// Rule execution statistics
#[derive(Debug, Clone, Default)]
pub struct RuleStats {
    pub rules_added: u64,
    pub rules_removed: u64,
    pub rules_executed: u64,
    pub rules_failed: u64,
    pub rules_cleared: u64,
    pub total_execution_time: std::time::Duration,
}

impl RuleStats {
    /// Get average execution time
    pub fn average_execution_time(&self) -> std::time::Duration {
        if self.rules_executed > 0 {
            self.total_execution_time / self.rules_executed as u32
        } else {
            std::time::Duration::ZERO
        }
    }
    
    /// Get success rate
    pub fn success_rate(&self) -> f64 {
        if self.rules_executed > 0 {
            (self.rules_executed - self.rules_failed) as f64 / self.rules_executed as f64
        } else {
            0.0
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::message::{MessageType, OdinMessage};
    
    #[tokio::test]
    async fn test_rule_creation() {
        let rule = Rule::new(
            "test-rule".to_string(),
            "Test Rule".to_string(),
            "A test rule".to_string(),
        )
        .add_condition(Condition::ContentContains("hello".to_string()))
        .add_action(Action::Log {
            level: LogLevel::Info,
            message: "Rule triggered".to_string(),
        });
        
        assert!(rule.validate().is_ok());
        assert_eq!(rule.id, "test-rule");
        assert_eq!(rule.conditions.len(), 1);
        assert_eq!(rule.actions.len(), 1);
    }
    
    #[tokio::test]
    async fn test_rule_engine() {
        let engine = HELRuleEngine::new();
        
        let rule = Rule::new(
            "test-rule".to_string(),
            "Test Rule".to_string(),
            "A test rule".to_string(),
        )
        .add_condition(Condition::ContentContains("hello".to_string()))
        .add_action(Action::Log {
            level: LogLevel::Info,
            message: "Rule triggered".to_string(),
        });
        
        engine.add_rule(rule).await.unwrap();
        
        let rules = engine.list_rules().await;
        assert_eq!(rules.len(), 1);
        assert_eq!(rules[0].id, "test-rule");
    }
    
    #[tokio::test]
    async fn test_rule_matching() {
        let rule = Rule::new(
            "test-rule".to_string(),
            "Test Rule".to_string(),
            "A test rule".to_string(),
        )
        .add_condition(Condition::ContentContains("hello".to_string()));
        
        let message = OdinMessage::new(
            MessageType::Standard,
            "source",
            "target",
            "hello world",
            MessagePriority::Normal,
        );
        
        assert!(rule.matches(&message).await.unwrap());
        
        let message2 = OdinMessage::new(
            MessageType::Standard,
            "source",
            "target",
            "goodbye world",
            MessagePriority::Normal,
        );
        
        assert!(!rule.matches(&message2).await.unwrap());
    }
    
    #[tokio::test]
    async fn test_condition_evaluation() {
        let condition = Condition::ContentContains("test".to_string());
        
        let message = OdinMessage::new(
            MessageType::Standard,
            "source",
            "target",
            "this is a test message",
            MessagePriority::Normal,
        );
        
        assert!(condition.evaluate(&message).await.unwrap());
    }
}