mod env;
mod host;

use std::cell::RefCell;
use std::convert::Infallible;
use std::rc::Rc;
use std::sync::Arc;

use avril_caps::{Capabilities, Category, Pledge};
use avril_core::{Extension, Op, PublicModule};
use avril_host::environment::Environment;

pub fn init(
    caps: Arc<Capabilities>,
    environment: Rc<RefCell<Environment>>,
    args: Vec<String>,
) -> Extension {
    let mut ops = env::ops(caps.clone(), environment);
    ops.extend(host::ops(caps.clone(), args));
    ops.push(Op::new(
        "op_pledge",
        move |request: Vec<(String, Option<Vec<String>>, Vec<String>)>| {
            let error = request
                .into_iter()
                .map(|(category, allow, deny)| {
                    category
                        .parse::<Category>()
                        .map(|category| (category, allow, deny))
                })
                .collect::<Result<Pledge, _>>()
                .and_then(|request| caps.pledge(request))
                .map_err(|error| error.to_string())
                .err();
            Ok::<_, Infallible>(error)
        },
    ));
    Extension {
        name: "ext:base",
        dependencies: &[
            "ext:console",
            "ext:file",
            "ext:http",
            "ext:net",
            "ext:process",
            "ext:stdio",
            "ext:test",
            "ext:web",
        ],
        ops,
        modules: const {
            &[
                PUBLIC_MODULES[0].module,
                PUBLIC_MODULES[1].module,
                (
                    "ext:base/env.js",
                    include_str!(concat!(env!("OUT_DIR"), "/env.js")),
                ),
                (
                    "ext:base/host.js",
                    include_str!(concat!(env!("OUT_DIR"), "/host.js")),
                ),
                (
                    "ext:base/pledge.js",
                    include_str!(concat!(env!("OUT_DIR"), "/pledge.js")),
                ),
            ]
        },
        entry_point: Some("ext:base/main.js"),
    }
}

pub const PUBLIC_MODULES: &[PublicModule] = &[
    avril_core::public_module!("avril:std", "ext:base", "main"),
    avril_core::public_module!("avril:std/sync", "ext:base", "sync"),
];