use std::sync::{Arc, OnceLock};
// Re-export common Rhai types for convenience
pub use rhai::Engine;

// Re-export specific functions from sal-os package

// Re-export Redis client module registration function

// Re-export PostgreSQL client module registration function


// Re-export virt functions from sal-virt package


/// Engine factory for creating and sharing Rhai engines with SAL modules.
pub struct EngineFactory {
    engine: Arc<Engine>,
}

impl EngineFactory {
    /// Create a new engine factory with a configured Rhai engine.
    pub fn new() -> Self {
        let mut engine = Engine::new();
        register_sal_modules(&mut engine);
        // Logger
        hero_logger::rhai_integration::configure_rhai_logging(&mut engine, "sal_runner");

        Self {
            engine: Arc::new(engine),
        }
    }

    /// Get a shared reference to the engine.
    pub fn get_engine(&self) -> Arc<Engine> {
        Arc::clone(&self.engine)
    }

    /// Get the global singleton engine factory.
    pub fn global() -> &'static EngineFactory {
        static FACTORY: OnceLock<EngineFactory> = OnceLock::new();
        FACTORY.get_or_init(|| EngineFactory::new())
    }
}

pub fn register_sal_modules(engine: &mut Engine) {
    let _ = sal_os::rhai::register_os_module(engine);
    let _ = sal_redisclient::rhai::register_redisclient_module(engine);
    let _ = sal_postgresclient::rhai::register_postgresclient_module(engine);
    let _ = sal_process::rhai::register_process_module(engine);
    let _ = sal_virt::rhai::register_virt_module(engine);
    let _ = sal_git::rhai::register_git_module(engine);
    let _ = sal_zinit_client::rhai::register_zinit_module(engine);
    let _ = sal_mycelium::rhai::register_mycelium_module(engine);
    let _ = sal_text::rhai::register_text_module(engine);
    let _ = sal_net::rhai::register_net_module(engine);
    let _ = sal_kubernetes::rhai::register_kubernetes_module(engine);
    let _ = sal_hetzner::rhai::register_hetzner_module(engine);

    println!("SAL modules registered successfully.");
}

/// Create a new SAL engine instance.
pub fn create_sal_engine() -> Engine {
    let mut engine = Engine::new();
    register_sal_modules(&mut engine);
    hero_logger::rhai_integration::configure_rhai_logging(&mut engine, "sal_runner");
    engine
}

/// Create a shared system engine using the factory.
pub fn create_shared_sal_engine() -> Arc<Engine> {
    EngineFactory::global().get_engine()
}