pub mod core;

/// Generates a module definition, and the corresponding macro [`require_api!`]
/// macro, behind a feature gate, and creates a facade macro that provides
/// a helpful error message if the feature hasn't been enabled in the ark API.
macro_rules! declare_module_apis {
    (
        $(
            #[feature = $feature:expr] mod $name:ident:
            macro $macro_name:ident ($($macro_args:tt)*) { $($macro_block:tt)* }
        )+
    ) => {
        $(
            #[cfg(feature = $feature)]
            pub mod $name;

            /// Macro to require and use the API.
            #[macro_export]
            #[cfg(not(feature = $feature))]
            macro_rules! $macro_name {
                ($($macro_args)*) => {
                    compile_error!(
                        concat!(
                            "Feature `",
                            stringify!($name),
                            "` not enabled. You must enable the feature in \
                             `ark` in your `Cargo.toml` to be able to use this API."
                        )
                    );
                }
            }

            /// Macro to require and use the API.
            #[macro_export]
            #[cfg(feature = $feature)]
            macro_rules! $macro_name {
                ($($macro_args)*) => { $($macro_block)* }
            }
        )+
    }
}

declare_module_apis! {

    #[feature = "applet"] mod applet: macro require_applet_api() {
        #[no_mangle]
        #[used]
        pub static ARK_API_APPLET: u64 = $crate::applet::FFI_API.id;

        pub fn applet() -> &'static $crate::applet::Applet {
            &$crate::applet::Applet {}
        }
    }

    #[feature = "behavior_controller"] mod behavior_controller: macro require_behavior_controller_api() {
        #[no_mangle]
        #[used]
        pub static ARK_API_BEHAVIOR_CONTROLLER: u64 = $crate::behavior_controller::FFI_API.id;
        pub fn behavior_controller() -> &'static $crate::behavior_controller::BehaviorController {
            &$crate::behavior_controller::BehaviorController {}
        }
    }

    #[feature = "behavior"] mod behavior: macro require_behavior_api() {
        #[no_mangle]
        #[used]
        pub static ARK_API_BEHAVIOR: u64 = $crate::behavior::FFI_API.id;
        pub fn behavior() -> &'static $crate::behavior::Behavior {
            &$crate::behavior::Behavior
        }
    }

    #[feature = "file_ux"] mod file_ux: macro require_file_ux_api() {
        #[no_mangle]
        #[used]
        pub static ARK_API_FILE_UX: u64 = $crate::file_ux::FFI_API.id;
        pub fn file_ux() -> &'static $crate::file_ux::FileUX {
            &$crate::file_ux::FileUX {}
        }
    }

    #[feature = "http_request"] mod http_request: macro require_http_request_api() {
        #[no_mangle]
        #[used]
        pub static ARK_API_HTTP_REQUEST: u64 = $crate::http_request::FFI_API.id;
    }

    #[feature = "http_client"] mod http_client: macro require_http_client_api() {
        #[no_mangle]
        #[used]
        pub static ARK_API_HTTP_CLIENT: u64 = $crate::http_client::FFI_API.id;
    }

    #[feature = "ml"] mod ml: macro require_ml_api() {
        #[no_mangle]
        #[used]
        pub static ARK_API_ML: u64 = $crate::ml::FFI_API.id;
    }

    #[feature = "ml-inference"] mod ml_inference: macro require_ml_inference_api() {
        #[no_mangle]
        #[used]
        pub static ARK_API_ML_INFERENCE: u64 = $crate::ml_inference::FFI_API.id;
    }

    #[feature = "module_run"] mod module_run: macro require_module_run_api() {
        #[no_mangle]
        #[used]
        pub static ARK_API_MODULE_RUN: u64 = $crate::module_run::FFI_API.id;
    }

    #[feature = "profiler"] mod profiler: macro require_profiler_api() {
        #[no_mangle]
        #[used]
        pub static ARK_API_PROFILER: u64 = $crate::profiler::FFI_API.id;
    }

    #[feature = "render"] mod render: macro require_render_api() {
        #[no_mangle]
        #[used]
        pub static ARK_API_RENDER: u64 = $crate::render::FFI_API.id;
        pub fn render() -> $crate::render::Render {
            $crate::render::Render::__create()
        }
    }

    #[feature = "unstable-render"] mod unstable_render: macro require_unstable_render_api() {
        #[no_mangle]
        #[used]
        pub static ARK_API_UNSTABLE_RENDER: u64 = $crate::unstable_render::FFI_API.id;
        pub fn unstable_render() -> $crate::unstable_render::UnstableRender {
            $crate::unstable_render::UnstableRender::__create()
        }
    }

    #[feature = "resource"] mod resource: macro require_resource_api() {
        #[no_mangle]
        #[used]
        pub static ARK_API_RESOURCE: u64 = $crate::resource::FFI_API.id;
    }

    #[feature = "storage"] mod storage: macro require_storage_api() {
        #[no_mangle]
        #[used]
        pub static ARK_API_STORAGE: u64 = $crate::storage::FFI_API.id;
    }

    #[feature = "telemetry"] mod telemetry: macro require_telemetry_api() {
        #[no_mangle]
        #[used]
        pub static ARK_API_TELEMETRY: u64 = $crate::telemetry::FFI_API.id;
    }

    #[feature = "time"] mod time: macro require_time_api() {
        #[no_mangle]
        #[used]
        pub static ARK_API_TIME: u64 = $crate::time::FFI_API.id;
        pub fn time() -> &'static $crate::time::Time {
            &$crate::time::Time {}
        }
    }

    #[feature = "user"] mod user: macro require_user_api() {
        #[no_mangle]
        #[used]
        pub static ARK_API_USER: u64 = $crate::user::FFI_API.id;
        pub fn user() -> &'static $crate::user::User {
            &$crate::user::User {}
        }
    }

    #[feature = "world"] mod world: macro require_world_api() {
        #[no_mangle]
        #[used]
        pub static ARK_API_WORLD: u64 = $crate::world::FFI_API.id;

        #[inline]
        pub fn entity_messenger() -> &'static mut $crate::world::EntityMessenger {
            $crate::world::EntityMessenger::get()
        }
    }

    #[feature = "feature-toggle"] mod feature_toggle: macro require_feature_toggle_api() {
        #[no_mangle]
        #[used]
        pub static ARK_API_FEATURE_TOGGLE: u64 = $crate::feature_toggle::FFI_API.id;
    }
}