qorzen_oxide/app/

native.rs

// src/app.rs - Enhanced application core with all systems integrated

use std::collections::HashMap;
use std::path::Path;
use std::sync::Arc;
use std::time::Duration;

use async_trait::async_trait;
use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use tokio::sync::{broadcast, Mutex, RwLock};
use tokio::time::{interval, timeout};
use uuid::Uuid;

use crate::auth::{
    AccountManager, MemorySessionStore, MemoryUserStore, SecurityPolicy, User, UserSession,
};
#[cfg(not(target_arch = "wasm32"))]
use crate::concurrency::ConcurrencyManager;
use crate::config::{ConfigurationTier, MemoryConfigStore, TieredConfigManager};
use crate::error::{Error, ErrorKind, Result}; // Removed unused imports
use crate::event::EventBusManager;
#[cfg(not(target_arch = "wasm32"))]
use crate::file::FileManager;
#[cfg(not(target_arch = "wasm32"))]
use crate::logging::LoggingManager;
use crate::manager::{HealthStatus, ManagedState, Manager, ManagerState, ManagerStatus};
use crate::platform::PlatformManager;
use crate::plugin::PluginManager;
#[cfg(not(target_arch = "wasm32"))]
use crate::task::TaskManager;
use crate::ui::UILayoutManager;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum ApplicationState {
    Created,
    Initializing,
    Running,
    ShuttingDown,
    Shutdown,
    Error,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ApplicationHealth {
    pub status: HealthStatus,
    pub uptime: Duration,
    pub managers: HashMap<String, HealthStatus>,
    pub last_check: DateTime<Utc>,
    pub details: HashMap<String, serde_json::Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ApplicationStats {
    pub version: String,
    pub started_at: DateTime<Utc>,
    pub uptime: Duration,
    pub state: ApplicationState,
    pub manager_count: usize,
    pub initialized_managers: usize,
    pub failed_managers: usize,
    pub memory_usage_bytes: u64,
    pub cpu_usage_percent: f64,
    pub system_info: SystemInfo,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SystemInfo {
    pub os_name: String,
    pub os_version: String,
    pub arch: String,
    pub cpu_cores: usize,
    pub total_memory_bytes: u64,
    pub available_memory_bytes: u64,
    pub hostname: String,
}

impl SystemInfo {
    pub fn collect() -> Self {
        Self {
            os_name: std::env::consts::OS.to_string(),
            os_version: "1.0".to_string(),
            arch: std::env::consts::ARCH.to_string(),
            cpu_cores: num_cpus::get(),
            total_memory_bytes: 0,
            available_memory_bytes: 0,
            hostname: hostname::get()
                .unwrap_or_default()
                .to_string_lossy()
                .to_string(),
        }
    }
}

/// Enhanced Application Core with all systems integrated
pub struct ApplicationCore {
    state: ManagedState,
    app_state: Arc<RwLock<ApplicationState>>,
    started_at: DateTime<Utc>,

    // Platform abstraction (must be first)
    platform_manager: Option<PlatformManager>,

    // Core configuration and settings
    config_manager: Option<Arc<Mutex<TieredConfigManager>>>,

    // Enhanced core managers
    logging_manager: Option<LoggingManager>,
    account_manager: Option<AccountManager>,

    // Existing managers (enhanced)
    event_bus_manager: Option<Arc<EventBusManager>>,
    file_manager: Option<FileManager>,
    concurrency_manager: Option<ConcurrencyManager>,
    task_manager: Option<TaskManager>,

    // New systems
    plugin_manager: Option<PluginManager>,
    ui_layout_manager: Option<UILayoutManager>,

    // Application lifecycle
    shutdown_signal: broadcast::Sender<()>,
    health_check_interval: Duration,

    // Current user context
    current_user: Arc<RwLock<Option<User>>>,
    current_session: Arc<RwLock<Option<UserSession>>>,

    // System monitoring
    system_info: SystemInfo,
    manager_registry: HashMap<String, Box<dyn Manager>>,
}

impl std::fmt::Debug for ApplicationCore {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("ApplicationCore")
            .field("started_at", &self.started_at)
            .field("system_info", &self.system_info)
            .finish()
    }
}

impl ApplicationCore {
    /// Creates a new application core
    pub fn new() -> Self {
        let (shutdown_signal, _) = broadcast::channel(1);

        Self {
            state: ManagedState::new(Uuid::new_v4(), "application_core"),
            app_state: Arc::new(RwLock::new(ApplicationState::Created)),
            started_at: Utc::now(),
            platform_manager: None,
            config_manager: None,
            logging_manager: None,
            account_manager: None,
            event_bus_manager: None,
            file_manager: None,
            concurrency_manager: None,
            task_manager: None,
            plugin_manager: None,
            ui_layout_manager: None,
            shutdown_signal,
            health_check_interval: Duration::from_secs(30),
            current_user: Arc::new(RwLock::new(None)),
            current_session: Arc::new(RwLock::new(None)),
            system_info: SystemInfo::collect(),
            manager_registry: HashMap::new(),
        }
    }

    /// Creates application with custom config file
    pub fn with_config_file(_config_path: impl AsRef<Path>) -> Self {
        // let app = Self::new();
        // Config file handling would be implemented here
        // app
        Self::new()
    }

    /// Enhanced initialization with complete system setup
    pub async fn initialize(&mut self) -> Result<()> {
        *self.app_state.write().await = ApplicationState::Initializing;
        self.state.set_state(ManagerState::Initializing).await;

        tracing::info!("Starting Qorzen application initialization");

        // 1. Initialize platform manager first (critical dependency)
        self.init_platform_manager().await?;

        // 2. Initialize configuration system
        self.init_config_manager().await?;

        // 3. Initialize logging with configuration
        self.init_logging_manager().await?;

        // 4. Initialize core application managers
        self.init_concurrency_manager().await?;
        self.init_event_bus_manager().await?;
        self.init_file_manager().await?;
        self.init_task_manager().await?;

        // 5. Initialize authentication and authorization
        self.init_account_manager().await?;

        // 6. Initialize UI and plugin systems
        self.init_ui_layout_manager().await?;
        self.init_plugin_manager().await?;

        // 7. Start background services
        self.start_background_services().await?;

        // 8. Setup signal handling
        self.setup_signal_handlers().await?;

        *self.app_state.write().await = ApplicationState::Running;
        self.state.set_state(ManagerState::Running).await;

        tracing::info!("Qorzen application initialization complete");
        Ok(())
    }

    async fn init_platform_manager(&mut self) -> Result<()> {
        tracing::info!("Initializing platform manager");
        let mut platform_manager = PlatformManager::new()?;
        platform_manager.initialize().await?;
        self.platform_manager = Some(platform_manager);
        Ok(())
    }

    async fn init_config_manager(&mut self) -> Result<()> {
        tracing::info!("Initializing configuration manager");
        let mut config_manager = TieredConfigManager::new();

        // Add configuration stores for different tiers
        config_manager.add_store(
            ConfigurationTier::System,
            Box::new(MemoryConfigStore::new(ConfigurationTier::System)),
        );
        config_manager.add_store(
            ConfigurationTier::Runtime,
            Box::new(MemoryConfigStore::new(ConfigurationTier::Runtime)),
        );

        config_manager.initialize().await?;
        self.config_manager = Some(Arc::new(Mutex::new(config_manager)));
        Ok(())
    }

    async fn init_logging_manager(&mut self) -> Result<()> {
        tracing::info!("Initializing logging manager");
        let config = if let Some(config_manager) = &self.config_manager {
            // Get logging config from configuration system
            let manager = config_manager.lock().await;
            manager
                .get("logging")
                .await
                .unwrap_or(None)
                .unwrap_or_else(crate::config::LoggingConfig::default)
        } else {
            crate::config::LoggingConfig::default()
        };

        let mut logging_manager = LoggingManager::new(config);
        logging_manager.initialize().await?;
        self.logging_manager = Some(logging_manager);
        Ok(())
    }

    async fn init_concurrency_manager(&mut self) -> Result<()> {
        tracing::info!("Initializing concurrency manager");
        let config = if let Some(config_manager) = &self.config_manager {
            let manager = config_manager.lock().await;
            manager
                .get("concurrency")
                .await
                .unwrap_or(None)
                .unwrap_or_else(crate::config::ConcurrencyConfig::default)
        } else {
            crate::config::ConcurrencyConfig::default()
        };

        let mut concurrency_manager = ConcurrencyManager::new(config)?;
        concurrency_manager.initialize().await?;
        self.concurrency_manager = Some(concurrency_manager);
        Ok(())
    }

    async fn init_event_bus_manager(&mut self) -> Result<()> {
        tracing::info!("Initializing event bus manager");
        let config = if let Some(config_manager) = &self.config_manager {
            let manager = config_manager.lock().await;
            manager
                .get("event_bus")
                .await
                .unwrap_or(None)
                .unwrap_or_default()
        } else {
            crate::config::EventBusConfig::default()
        };

        let event_config = crate::event::EventBusConfig {
            worker_count: config.worker_count,
            queue_capacity: config.queue_size,
            default_timeout: Duration::from_millis(config.publish_timeout_ms),
            enable_persistence: config.enable_persistence,
            enable_metrics: config.enable_metrics,
            batch_size: 100,
            max_retry_delay: Duration::from_secs(60),
        };

        let mut event_bus_manager = EventBusManager::new(event_config);
        event_bus_manager.initialize().await?;
        self.event_bus_manager = Some(Arc::new(event_bus_manager));
        Ok(())
    }

    async fn init_file_manager(&mut self) -> Result<()> {
        tracing::info!("Initializing file manager");
        let config = if let Some(config_manager) = &self.config_manager {
            let manager = config_manager.lock().await;
            manager
                .get("files")
                .await
                .unwrap_or(None)
                .unwrap_or_else(crate::config::FileConfig::default)
        } else {
            crate::config::FileConfig::default()
        };

        let mut file_manager = FileManager::new(config);

        // Set event bus for file events
        if let Some(event_bus) = &self.event_bus_manager {
            file_manager.set_event_bus(Arc::clone(event_bus));
        }

        file_manager.initialize().await?;
        self.file_manager = Some(file_manager);
        Ok(())
    }

    async fn init_task_manager(&mut self) -> Result<()> {
        tracing::info!("Initializing task manager");
        let config = if let Some(config_manager) = &self.config_manager {
            let manager = config_manager.lock().await;
            manager
                .get("tasks")
                .await
                .unwrap_or(None)
                .unwrap_or_default()
        } else {
            crate::config::TaskConfig::default()
        };

        let mut task_manager = TaskManager::new(config);

        // Set event bus for task events
        if let Some(event_bus) = &self.event_bus_manager {
            task_manager.set_event_bus(Arc::clone(event_bus));
        }

        task_manager.initialize().await?;
        self.task_manager = Some(task_manager);
        Ok(())
    }

    async fn init_account_manager(&mut self) -> Result<()> {
        tracing::info!("Initializing account manager");
        let security_policy = if let Some(config_manager) = &self.config_manager {
            let manager = config_manager.lock().await;
            manager
                .get("security")
                .await
                .unwrap_or(None)
                .unwrap_or_else(SecurityPolicy::default)
        } else {
            SecurityPolicy::default()
        };

        let session_store = Box::new(MemorySessionStore::new());
        let user_store = Box::new(MemoryUserStore::new());

        let mut account_manager = AccountManager::new(session_store, user_store, security_policy);
        account_manager.initialize().await?;
        self.account_manager = Some(account_manager);
        Ok(())
    }

    async fn init_ui_layout_manager(&mut self) -> Result<()> {
        tracing::info!("Initializing UI layout manager");
        let mut ui_layout_manager = UILayoutManager::new();
        ui_layout_manager.initialize().await?;
        self.ui_layout_manager = Some(ui_layout_manager);
        Ok(())
    }

    async fn init_plugin_manager(&mut self) -> Result<()> {
        tracing::info!("Initializing plugin manager");

        // Create a simple plugin loader for this example
        let loader = Box::new(SimplePluginLoader::new());
        let mut plugin_manager = PluginManager::new(loader);
        plugin_manager.initialize().await?;
        self.plugin_manager = Some(plugin_manager);
        Ok(())
    }

    async fn start_background_services(&self) -> Result<()> {
        tracing::info!("Starting background services");

        // Start health monitoring
        self.start_health_monitoring().await?;

        // Start configuration sync (if enabled)
        if let Some(config_manager) = self.config_manager.as_ref().cloned() {
            tokio::spawn(async move {
                let mut interval = interval(Duration::from_secs(300));
                loop {
                    interval.tick().await;
                    let result = {
                        let manager = config_manager.lock().await;
                        manager.sync().await
                    };

                    if let Err(e) = result {
                        tracing::error!("Configuration sync failed: {}", e);
                    }
                }
            });
        }

        Ok(())
    }

    async fn start_health_monitoring(&self) -> Result<()> {
        let health_interval = self.health_check_interval;
        let app_state = Arc::clone(&self.app_state);

        tokio::spawn(async move {
            let mut interval = interval(health_interval);

            loop {
                interval.tick().await;

                let state = *app_state.read().await;
                if state != ApplicationState::Running {
                    break;
                }

                // Perform health checks
                // In a real implementation, this would check all managers
                tracing::debug!("Performing health check");
            }
        });

        Ok(())
    }

    async fn setup_signal_handlers(&self) -> Result<()> {
        let shutdown_sender = self.shutdown_signal.clone();
        let app_state = Arc::clone(&self.app_state);

        tokio::spawn(async move {
            #[cfg(unix)]
            {
                use tokio::signal::unix::{signal, SignalKind};

                let mut sigterm =
                    signal(SignalKind::terminate()).expect("Failed to register SIGTERM handler");
                let mut sigint =
                    signal(SignalKind::interrupt()).expect("Failed to register SIGINT handler");

                tokio::select! {
                    _ = sigterm.recv() => {
                        tracing::info!("Received SIGTERM, initiating graceful shutdown");
                    }
                    _ = sigint.recv() => {
                        tracing::info!("Received SIGINT, initiating graceful shutdown");
                    }
                }
            }

            #[cfg(windows)]
            {
                use tokio::signal;

                signal::ctrl_c().await.expect("Failed to listen for ctrl+c");
                tracing::info!("Received Ctrl+C, initiating graceful shutdown");
            }

            #[cfg(target_arch = "wasm32")]
            {
                // WASM doesn't support signal handling
                // Could implement custom shutdown mechanism here
            }

            *app_state.write().await = ApplicationState::ShuttingDown;
            let _ = shutdown_sender.send(());
        });

        Ok(())
    }

    /// Graceful shutdown of all systems
    pub async fn shutdown(&mut self) -> Result<()> {
        *self.app_state.write().await = ApplicationState::ShuttingDown;
        self.state.set_state(ManagerState::ShuttingDown).await;

        tracing::info!("Shutting down Qorzen application");

        // Shutdown in reverse dependency order
        if let Some(mut plugin_manager) = self.plugin_manager.take() {
            let _ = timeout(Duration::from_secs(10), plugin_manager.shutdown()).await;
        }

        if let Some(mut ui_layout_manager) = self.ui_layout_manager.take() {
            let _ = timeout(Duration::from_secs(5), ui_layout_manager.shutdown()).await;
        }

        if let Some(mut account_manager) = self.account_manager.take() {
            let _ = timeout(Duration::from_secs(5), account_manager.shutdown()).await;
        }

        if let Some(mut task_manager) = self.task_manager.take() {
            let _ = timeout(Duration::from_secs(10), task_manager.shutdown()).await;
        }

        if let Some(mut file_manager) = self.file_manager.take() {
            let _ = timeout(Duration::from_secs(5), file_manager.shutdown()).await;
        }

        if let Some(event_bus_manager) = self.event_bus_manager.take() {
            if let Ok(mut manager) = Arc::try_unwrap(event_bus_manager) {
                let _ = timeout(Duration::from_secs(5), manager.shutdown()).await;
            }
        }

        if let Some(mut concurrency_manager) = self.concurrency_manager.take() {
            let _ = timeout(Duration::from_secs(10), concurrency_manager.shutdown()).await;
        }

        if let Some(mut logging_manager) = self.logging_manager.take() {
            let _ = timeout(Duration::from_secs(5), logging_manager.shutdown()).await;
        }

        if let Some(config_manager) = self.config_manager.take() {
            let mut manager = config_manager.lock().await;
            let _ = timeout(Duration::from_secs(2), manager.shutdown()).await;
        }

        if let Some(mut platform_manager) = self.platform_manager.take() {
            let _ = timeout(Duration::from_secs(5), platform_manager.shutdown()).await;
        }

        *self.app_state.write().await = ApplicationState::Shutdown;
        self.state.set_state(ManagerState::Shutdown).await;

        tracing::info!("Qorzen application shutdown complete");
        Ok(())
    }

    /// Waits for shutdown signal
    pub async fn wait_for_shutdown(&self) -> Result<()> {
        let mut receiver = self.shutdown_signal.subscribe();
        receiver.recv().await.map_err(|_| {
            Error::new(
                ErrorKind::Application,
                "Shutdown signal channel closed unexpectedly",
            )
        })?;
        Ok(())
    }

    /// Gets current application health
    pub async fn get_health(&self) -> ApplicationHealth {
        let mut manager_health = HashMap::new();
        let mut overall_healthy = true;

        // Check each manager's health
        if let Some(platform_manager) = &self.platform_manager {
            let health = platform_manager.health_check().await;
            if health != HealthStatus::Healthy {
                overall_healthy = false;
            }
            manager_health.insert("platform_manager".to_string(), health);
        }

        if let Some(config_manager) = &self.config_manager {
            let manager = config_manager.lock().await;
            let health = manager.health_check().await;
            if health != HealthStatus::Healthy {
                overall_healthy = false;
            }
            manager_health.insert("config_manager".to_string(), health);
        }

        // Add other managers...

        let overall_status = if overall_healthy {
            HealthStatus::Healthy
        } else {
            HealthStatus::Degraded
        };

        ApplicationHealth {
            status: overall_status,
            uptime: Utc::now()
                .signed_duration_since(self.started_at)
                .to_std()
                .unwrap_or_default(),
            managers: manager_health,
            last_check: Utc::now(),
            details: HashMap::new(),
        }
    }

    /// Gets application statistics
    pub async fn get_stats(&self) -> ApplicationStats {
        ApplicationStats {
            version: crate::VERSION.to_string(),
            started_at: self.started_at,
            uptime: Utc::now()
                .signed_duration_since(self.started_at)
                .to_std()
                .unwrap_or_default(),
            state: *self.app_state.read().await,
            manager_count: self.manager_registry.len(),
            initialized_managers: self.manager_registry.len(), // Simplified
            failed_managers: 0,                                // Simplified
            memory_usage_bytes: 0,                             // Would use platform-specific APIs
            cpu_usage_percent: 0.0,                            // Would use platform-specific APIs
            system_info: self.system_info.clone(),
        }
    }

    /// Gets current user
    pub async fn current_user(&self) -> Option<User> {
        self.current_user.read().await.clone()
    }

    /// Gets current session
    pub async fn current_session(&self) -> Option<UserSession> {
        self.current_session.read().await.clone()
    }

    /// Gets application state
    pub async fn get_state(&self) -> ApplicationState {
        *self.app_state.read().await
    }
}

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

#[async_trait]
impl Manager for ApplicationCore {
    fn name(&self) -> &str {
        "application_core"
    }

    fn id(&self) -> Uuid {
        self.state.id()
    }

    async fn initialize(&mut self) -> Result<()> {
        // Main initialization is handled by the public initialize method
        Ok(())
    }

    async fn shutdown(&mut self) -> Result<()> {
        // Main shutdown is handled by the public shutdown method
        Ok(())
    }

    async fn status(&self) -> ManagerStatus {
        let mut status = self.state.status().await;
        let app_stats = self.get_stats().await;

        status.add_metadata(
            "app_state",
            serde_json::Value::String(format!("{:?}", app_stats.state)),
        );
        status.add_metadata(
            "uptime_seconds",
            serde_json::Value::from(app_stats.uptime.as_secs()),
        );
        status.add_metadata(
            "manager_count",
            serde_json::Value::from(app_stats.manager_count),
        );
        status.add_metadata("version", serde_json::Value::String(app_stats.version));

        status
    }

    async fn health_check(&self) -> HealthStatus {
        let health = self.get_health().await;
        health.status
    }
}

/// Simple plugin loader for demonstration
struct SimplePluginLoader {
    // Plugin loading implementation
}

impl SimplePluginLoader {
    fn new() -> Self {
        Self {}
    }
}

#[async_trait]
impl crate::plugin::PluginLoader for SimplePluginLoader {
    async fn load_plugin(&self, _path: &str) -> Result<Box<dyn crate::plugin::Plugin>> {
        Err(Error::plugin(
            "loader",
            "Plugin loading not implemented in example",
        ))
    }

    async fn validate_plugin(
        &self,
        _plugin: &dyn crate::plugin::Plugin,
    ) -> Result<crate::plugin::ValidationResult> {
        Ok(crate::plugin::ValidationResult {
            is_valid: true,
            errors: Vec::new(),
            warnings: Vec::new(),
        })
    }

    async fn unload_plugin(&self, _plugin_id: &str) -> Result<()> {
        Ok(())
    }
}

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

    #[tokio::test]
    async fn test_application_lifecycle() {
        let mut app = ApplicationCore::new();

        assert_eq!(app.get_state().await, ApplicationState::Created);

        app.initialize().await.unwrap();
        assert_eq!(app.get_state().await, ApplicationState::Running);

        app.shutdown().await.unwrap();
        assert_eq!(app.get_state().await, ApplicationState::Shutdown);
    }

    #[tokio::test]
    async fn test_application_health() {
        let mut app = ApplicationCore::new();
        app.initialize().await.unwrap();

        let health = app.get_health().await;
        assert!(matches!(
            health.status,
            HealthStatus::Healthy | HealthStatus::Degraded
        ));

        app.shutdown().await.unwrap();
    }

    #[tokio::test]
    async fn test_application_stats() {
        let mut app = ApplicationCore::new();
        app.initialize().await.unwrap();

        let stats = app.get_stats().await;
        assert_eq!(stats.version, crate::VERSION);
        assert_eq!(stats.state, ApplicationState::Running);

        app.shutdown().await.unwrap();
    }
}