use heromodels::models::heroledger::rhai::register_heroledger_rhai_modules;
use rhai::Engine;
use rhailib_dsl;
use std::sync::{Arc, OnceLock};

/// Engine factory for creating and sharing Rhai engines.
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_dsl_modules(&mut engine);
        // Logger
        hero_logger::rhai_integration::configure_rhai_logging(&mut engine, "osis_actor");

        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())
    }
}

/// Register basic object functions directly in the engine.
/// This provides object functionality without relying on the problematic rhailib_dsl object module.
fn register_object_functions(engine: &mut Engine) {
    use heromodels::models::object::Object;

    // Register the Object type
    engine.register_type_with_name::<Object>("Object");

    // Register constructor function
    engine.register_fn("new_object", || Object::new());

    // Register setter functions
    engine.register_fn("object_title", |obj: &mut Object, title: String| {
        obj.title = title;
        obj.clone()
    });

    engine.register_fn(
        "object_description",
        |obj: &mut Object, description: String| {
            obj.description = description;
            obj.clone()
        },
    );

    // Register getter functions
    engine.register_fn("get_object_id", |obj: &mut Object| obj.id() as i64);
    engine.register_fn("get_object_title", |obj: &mut Object| obj.title.clone());
    engine.register_fn("get_object_description", |obj: &mut Object| {
        obj.description.clone()
    });
}

/// Registers all DSL modules with the provided Rhai engine.
///
/// This function is the main entry point for integrating the rhailib DSL with a Rhai engine.
/// It registers all business domain modules, making their functions available to Rhai scripts.
///
/// # Arguments
///
/// * `engine` - A mutable reference to the Rhai engine to register modules with
///
/// # Example
///
/// ```rust
/// use rhai::Engine;
/// use crate::engine::register_dsl_modules;
///
/// let mut engine = Engine::new();
/// register_dsl_modules(&mut engine);
///
/// // Engine now has access to all DSL functions
/// let result = engine.eval::<String>(r#"
///     let company = new_company().name("Test Corp");
///     company.name
/// "#).unwrap();
/// assert_eq!(result, "Test Corp");
/// ```
///
/// # Registered Modules
///
/// This function registers the following domain modules:
/// - Access control functions
/// - Business operation functions (companies, products, sales, shareholders)
/// - Calendar and scheduling functions
/// - Circle and community management functions
/// - Company management functions
/// - Contact management functions
/// - Core utility functions
/// - Financial operation functions (accounts, assets, marketplace)
/// - Workflow management functions (flows, steps, signatures)
/// - Library and content management functions
/// - Generic object manipulation functions (custom implementation)
pub fn register_dsl_modules(engine: &mut Engine) {
    rhailib_dsl::access::register_access_rhai_module(engine);
    rhailib_dsl::biz::register_biz_rhai_module(engine);
    rhailib_dsl::calendar::register_calendar_rhai_module(engine);
    rhailib_dsl::circle::register_circle_rhai_module(engine);
    rhailib_dsl::company::register_company_rhai_module(engine);
    rhailib_dsl::contact::register_contact_rhai_module(engine);
    rhailib_dsl::core::register_core_rhai_module(engine);
    rhailib_dsl::finance::register_finance_rhai_modules(engine);
    // rhailib_dsl::flow::register_flow_rhai_modules(engine);
    rhailib_dsl::library::register_library_rhai_module(engine);
    // Skip problematic object module for now - can be implemented separately if needed
    // rhailib_dsl::object::register_object_fns(engine);
    rhailib_dsl::payment::register_payment_rhai_module(engine);

    // Register basic object functionality directly
    register_object_functions(engine);
    heromodels::heroledger::rhai::register_heroledger_rhai_modules(&mut engine);


    println!("Rhailib Domain Specific Language modules registered successfully.");
}

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

/// Evaluate a Rhai script string.
pub fn eval_script(
    engine: &Engine,
    script: &str,
) -> Result<rhai::Dynamic, Box<rhai::EvalAltResult>> {
    engine.eval(script)
}