nerve/integration/

plugin_integration.rs

//! Plugin-Based System Integration for Nerve Framework
//!
//! Provides a plugin-based integration system that dynamically loads components
//! from separate packages using the plugin system architecture.

use nerve_core_errors::NerveResult;
use nerve_core_traits::{
    NerveComponent, NervePlugin,
};
use nerve_core_types::{
    ComponentType, SystemStatistics,
};
use nerve_plugin_system::PluginManager;
use std::sync::Arc;

use crate::integration::plugin_adapters::{
    CommunicationComponentAdapter, MemoryComponentAdapter, NodeComponentAdapter, ThreadComponentAdapter,
};
use crate::integration::plugin_traits::{
    PluginCommunicationComponent, PluginMemoryComponent, PluginNodeComponent, PluginThreadComponent,
};

/// Plugin-based system integration structure
///
/// This system uses the plugin manager to dynamically load and manage
/// all Nerve Framework components as separate packages.
pub struct PluginNerveSystem {
    /// Plugin manager for dynamic component loading
    plugin_manager: Arc<PluginManager>,
    /// System configuration
    config: SystemConfig,
    /// Loaded memory component
    memory_component: Option<Arc<dyn PluginMemoryComponent>>,
    /// Loaded thread component
    thread_component: Option<Arc<dyn PluginThreadComponent>>,
    /// Loaded node component
    node_component: Option<Arc<dyn PluginNodeComponent>>,
    /// Loaded communication component
    communication_component: Option<Arc<dyn PluginCommunicationComponent>>,
}

/// System configuration for plugin-based integration
#[derive(Debug, Clone)]
pub struct SystemConfig {
    /// Maximum memory usage in bytes
    pub max_memory_bytes: u64,
    /// Maximum number of threads
    pub max_threads: usize,
    /// Maximum message queue size
    pub max_queue_size: usize,
    /// Performance monitoring enabled
    pub performance_monitoring: bool,
    /// Plugin loading strategy
    pub plugin_loading_strategy: PluginLoadingStrategy,
}

/// Plugin loading strategy
#[derive(Debug, Clone)]
pub enum PluginLoadingStrategy {
    /// Load all available plugins
    LoadAll,
    /// Load only specified component types
    LoadSpecific(Vec<ComponentType>),
    /// Lazy loading - load plugins on demand
    LazyLoad,
}

impl Default for SystemConfig {
    fn default() -> Self {
        Self {
            max_memory_bytes: 1_000_000_000, // 1GB
            max_threads: 16,
            max_queue_size: 10_000,
            performance_monitoring: true,
            plugin_loading_strategy: PluginLoadingStrategy::LoadAll,
        }
    }
}

impl PluginNerveSystem {
    /// Create a new plugin-based Nerve System with default configuration
    pub fn new() -> NerveResult<Self> {
        Self::with_config(SystemConfig::default())
    }

    /// Create a new plugin-based Nerve System with custom configuration
    pub fn with_config(config: SystemConfig) -> NerveResult<Self> {
        // Validate configuration
        if config.max_memory_bytes == 0 {
            return Err(nerve_core_errors::NerveError::Configuration(
                "Maximum memory bytes must be greater than 0".to_string(),
            ));
        }

        if config.max_threads == 0 {
            return Err(nerve_core_errors::NerveError::Configuration(
                "Maximum threads must be greater than 0".to_string(),
            ));
        }

        if config.max_queue_size == 0 {
            return Err(nerve_core_errors::NerveError::Configuration(
                "Maximum queue size must be greater than 0".to_string(),
            ));
        }

        // Create plugin manager
        let plugin_manager = Arc::new(PluginManager::new());

        Ok(Self {
            plugin_manager,
            config,
            memory_component: None,
            thread_component: None,
            node_component: None,
            communication_component: None,
        })
    }

    /// Load all required plugins based on configuration
    pub fn load_plugins(&mut self) -> NerveResult<()> {
        println!("Loading plugins with strategy: {:?}", self.config.plugin_loading_strategy);

        // Extract the strategy to avoid borrowing issues
        let strategy = self.config.plugin_loading_strategy.clone();

        match strategy {
            PluginLoadingStrategy::LoadAll => {
                self.load_memory_plugin()?;
                self.load_thread_plugin()?;
                self.load_node_plugin()?;
                self.load_communication_plugin()?;
            }
            PluginLoadingStrategy::LoadSpecific(types) => {
                for component_type in types {
                    match component_type {
                        ComponentType::Memory => self.load_memory_plugin()?,
                        ComponentType::Thread => self.load_thread_plugin()?,
                        ComponentType::Node => self.load_node_plugin()?,
                        ComponentType::Communication => self.load_communication_plugin()?,
                        ComponentType::QoS | ComponentType::Integration => {
                            // These component types are not yet implemented in plugin system
                            println!("⚠️  Component type {:?} not yet supported in plugin system", component_type);
                        }
                    }
                }
            }
            PluginLoadingStrategy::LazyLoad => {
                // Don't load any plugins initially - they'll be loaded on demand
                println!("Lazy loading enabled - plugins will be loaded on demand");
            }
        }

        println!("Plugin loading completed successfully");
        Ok(())
    }

    /// Load memory plugin
    fn load_memory_plugin(&mut self) -> NerveResult<()> {
        use nerve_memory::{MemoryManager, MemoryPlugin};

        // Create and load the plugin
        let plugin = Arc::new(MemoryPlugin::new(self.config.max_memory_bytes));
        self.plugin_manager.load_plugin(plugin.clone())?;

        // Create adapter for the memory component
        let memory_manager = Arc::new(MemoryManager::new(self.config.max_memory_bytes));
        let adapter = Arc::new(MemoryComponentAdapter::new(memory_manager));

        // Store the memory component for direct access
        self.memory_component = Some(adapter);

        println!("✅ Memory plugin loaded successfully");
        Ok(())
    }

    /// Load thread plugin
    fn load_thread_plugin(&mut self) -> NerveResult<()> {
        use nerve_thread::{ThreadManager, ThreadPlugin};

        // Create and load the plugin
        let plugin = Arc::new(ThreadPlugin::new(self.config.max_threads));
        self.plugin_manager.load_plugin(plugin.clone())?;

        // Create adapter for the thread component
        let thread_manager = Arc::new(ThreadManager::new(self.config.max_threads));
        let adapter = Arc::new(ThreadComponentAdapter::new(thread_manager));

        // Store the thread component for direct access
        self.thread_component = Some(adapter);

        println!("✅ Thread plugin loaded successfully");
        Ok(())
    }

    /// Load node plugin
    fn load_node_plugin(&mut self) -> NerveResult<()> {
        use nerve_node::{NodeManager, NodePlugin};

        // Create and load the plugin
        let plugin = Arc::new(NodePlugin::new());
        self.plugin_manager.load_plugin(plugin.clone())?;

        // Create adapter for the node component
        let node_manager = Arc::new(NodeManager::new());
        let adapter = Arc::new(NodeComponentAdapter::new(node_manager));

        // Store the node component for direct access
        self.node_component = Some(adapter);

        println!("✅ Node plugin loaded successfully");
        Ok(())
    }

    /// Load communication plugin
    fn load_communication_plugin(&mut self) -> NerveResult<()> {
        use nerve_communication::{CommunicationManager, CommunicationPlugin};

        // Create and load the plugin
        let plugin = Arc::new(CommunicationPlugin::new());
        self.plugin_manager.load_plugin(plugin.clone())?;

        // Create adapter for the communication component
        let communication_manager = Arc::new(CommunicationManager::new());
        let adapter = Arc::new(CommunicationComponentAdapter::new(communication_manager));

        // Store the communication component for direct access
        self.communication_component = Some(adapter);

        println!("✅ Communication plugin loaded successfully");
        Ok(())
    }

    /// Get memory component (load if necessary)
    pub fn memory_component(&mut self) -> NerveResult<&Arc<dyn PluginMemoryComponent>> {
        if self.memory_component.is_none() {
            self.load_memory_plugin()?;
        }
        self.memory_component
            .as_ref()
            .ok_or_else(|| nerve_core_errors::NerveError::Component {
                component_type: nerve_core_types::ComponentType::Memory,
                message: "Memory component not available".to_string(),
            })
    }

    /// Get thread component (load if necessary)
    pub fn thread_component(&mut self) -> NerveResult<&Arc<dyn PluginThreadComponent>> {
        if self.thread_component.is_none() {
            self.load_thread_plugin()?;
        }
        self.thread_component
            .as_ref()
            .ok_or_else(|| nerve_core_errors::NerveError::Component {
                component_type: nerve_core_types::ComponentType::Thread,
                message: "Thread component not available".to_string(),
            })
    }

    /// Get node component (load if necessary)
    pub fn node_component(&mut self) -> NerveResult<&Arc<dyn PluginNodeComponent>> {
        if self.node_component.is_none() {
            self.load_node_plugin()?;
        }
        self.node_component
            .as_ref()
            .ok_or_else(|| nerve_core_errors::NerveError::Component {
                component_type: nerve_core_types::ComponentType::Node,
                message: "Node component not available".to_string(),
            })
    }

    /// Get communication component (load if necessary)
    pub fn communication_component(&mut self) -> NerveResult<&Arc<dyn PluginCommunicationComponent>> {
        if self.communication_component.is_none() {
            self.load_communication_plugin()?;
        }
        self.communication_component
            .as_ref()
            .ok_or_else(|| nerve_core_errors::NerveError::Component {
                component_type: nerve_core_types::ComponentType::Communication,
                message: "Communication component not available".to_string(),
            })
    }

    /// Get plugin manager reference
    pub fn plugin_manager(&self) -> &Arc<PluginManager> {
        &self.plugin_manager
    }

    /// Get system configuration
    pub fn config(&self) -> &SystemConfig {
        &self.config
    }

    /// Check if system is healthy
    pub fn is_healthy(&self) -> bool {
        self.plugin_manager.system_health()
    }

    /// Get system health status
    pub fn health_status(&self) -> String {
        if self.is_healthy() {
            "Healthy".to_string()
        } else {
            "Unhealthy".to_string()
        }
    }

    /// Get system statistics
    pub fn get_statistics(&self) -> SystemStatistics {
        let mut combined_stats = SystemStatistics::default();

        // Combine statistics from all loaded plugins
        for plugin in self.plugin_manager.get_all_plugins() {
            let plugin_stats = plugin.get_statistics();
            combined_stats.messages_processed += plugin_stats.messages_processed;
            combined_stats.errors_encountered += plugin_stats.errors_encountered;
            // Add other statistics fields as needed
        }

        combined_stats
    }

    /// Get loaded plugin types
    pub fn loaded_plugin_types(&self) -> Vec<ComponentType> {
        self.plugin_manager.get_loaded_plugin_types()
    }

    /// Get plugin count
    pub fn plugin_count(&self) -> usize {
        self.plugin_manager.get_all_plugins().len()
    }

    /// Demonstrate plugin-based message processing
    pub fn process_message(&mut self, topic: &str, payload: Vec<u8>) -> NerveResult<()> {
        println!("Processing message via plugin system...");

        // Step 1: Use memory component for allocation
        let memory_component = self.memory_component()?;
        println!("  Memory component: {} (healthy: {})",
            memory_component.id().name,
            memory_component.is_healthy()
        );

        // Step 2: Use communication component for message handling
        let communication_component = self.communication_component()?;
        println!("  Communication component: {} (healthy: {})",
            communication_component.id().name,
            communication_component.is_healthy()
        );

        // Step 3: Use thread component for coordination
        let thread_component = self.thread_component()?;
        println!("  Thread component: {} (healthy: {})",
            thread_component.id().name,
            thread_component.is_healthy()
        );

        // Step 4: Use node component for registration
        let node_component = self.node_component()?;
        println!("  Node component: {} (healthy: {})",
            node_component.id().name,
            node_component.is_healthy()
        );

        println!("  Message processed successfully via plugin system");
        println!("  Topic: {}, Payload size: {} bytes", topic, payload.len());

        Ok(())
    }

    /// Shutdown the plugin-based system gracefully
    pub fn shutdown(self) -> NerveResult<()> {
        println!("🔄 Starting plugin-based system shutdown...");

        // Plugin manager automatically handles plugin shutdown
        println!("✅ Plugin-based system shutdown complete");

        Ok(())
    }
}

impl Default for PluginNerveSystem {
    fn default() -> Self {
        Self::new().expect("Failed to create default PluginNerveSystem")
    }
}

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

    #[test]
    fn test_plugin_nerve_system_creation() {
        let system = PluginNerveSystem::new();
        assert!(system.is_ok());

        let mut system = system.unwrap();
        assert!(system.is_healthy());
    }

    #[test]
    fn test_plugin_nerve_system_with_config() {
        let config = SystemConfig {
            max_memory_bytes: 500_000_000,
            max_threads: 8,
            max_queue_size: 5_000,
            performance_monitoring: true,
            plugin_loading_strategy: PluginLoadingStrategy::LoadAll,
        };

        let system = PluginNerveSystem::with_config(config);
        assert!(system.is_ok());

        let system = system.unwrap();
        assert_eq!(system.config().max_memory_bytes, 500_000_000);
        assert_eq!(system.config().max_threads, 8);
        assert_eq!(system.config().max_queue_size, 5_000);
    }

    #[test]
    fn test_plugin_nerve_system_invalid_config() {
        let config = SystemConfig {
            max_memory_bytes: 0, // Invalid
            max_threads: 8,
            max_queue_size: 5_000,
            performance_monitoring: true,
            plugin_loading_strategy: PluginLoadingStrategy::LoadAll,
        };

        let system = PluginNerveSystem::with_config(config);
        assert!(system.is_err());
    }

    #[test]
    fn test_plugin_loading() {
        let mut system = PluginNerveSystem::new().unwrap();

        // Initially no plugins loaded
        assert_eq!(system.plugin_count(), 0);

        // Load plugins
        let result = system.load_plugins();
        assert!(result.is_ok());

        // Should have all plugins loaded
        assert_eq!(system.plugin_count(), 4);
        assert!(system.is_healthy());
    }

    #[test]
    fn test_system_statistics() {
        let system = PluginNerveSystem::new().unwrap();
        let stats = system.get_statistics();

        // Initial statistics should be zero
        assert_eq!(stats.messages_processed, 0);
        assert_eq!(stats.errors_encountered, 0);
    }

    #[test]
    fn test_health_status() {
        let system = PluginNerveSystem::new().unwrap();
        let status = system.health_status();

        // Initial system should be healthy
        assert_eq!(status, "Healthy");
    }
}