use avril_core::{Error, PublicModule, Runtime};

const MODULES: &[&[PublicModule]] = &[
    avril_ext_base::PUBLIC_MODULES,
    avril_ext_file::PUBLIC_MODULES,
    avril_ext_fjson::PUBLIC_MODULES,
    avril_ext_kv::PUBLIC_MODULES,
    avril_ext_task::PUBLIC_MODULES,
    avril_ext_path::PUBLIC_MODULES,
    avril_ffi::PUBLIC_MODULES,
    avril_ext_test::PUBLIC_MODULES,
];

fn public_modules() -> impl Iterator<Item = &'static PublicModule> {
    MODULES.iter().flat_map(|modules| modules.iter())
}

pub(crate) fn register(runtime: &mut Runtime) -> Result<(), Error> {
    public_modules().try_for_each(|module| module.register(runtime))
}

pub fn declarations() -> impl Iterator<Item = (String, &'static str)> {
    public_modules()
        .map(|module| {
            let name = module
                .name
                .strip_prefix("avril:")
                .expect("Public modules use the avril: scheme");
            (format!("{name}.d.ts"), module.declaration)
        })
        .chain(std::iter::once((
            "globals.d.ts".into(),
            include_str!("../stdlib/globals.d.ts"),
        )))
}

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

    #[test]
    fn public_module_names_are_unique_and_use_the_avril_scheme() {
        let mut names = std::collections::HashSet::new();
        for module in public_modules() {
            assert!(module.name.starts_with("avril:"), "{}", module.name);
            assert!(
                names.insert(module.name),
                "Duplicate module: {}",
                module.name
            );
        }
    }
}