use crate::api::{Client, models::Server};
use rhai::{Array, Dynamic, plugin::*};

pub fn register(engine: &mut Engine) {
    let server_module = exported_module!(server_api);
    engine.register_global_module(server_module.into());
}

#[export_module]
pub mod server_api {
    use crate::api::models::Cancellation;

    use super::*;
    use rhai::EvalAltResult;

    #[rhai_fn(name = "get_server", return_raw)]
    pub fn get_server(
        client: &mut Client,
        server_number: i64,
    ) -> Result<Server, Box<EvalAltResult>> {
        client
            .get_server(server_number as i32)
            .map_err(|e| e.to_string().into())
    }

    #[rhai_fn(name = "get_servers", return_raw)]
    pub fn get_servers(client: &mut Client) -> Result<Array, Box<EvalAltResult>> {
        let servers = client
            .get_servers()
            .map_err(|e| Into::<Box<EvalAltResult>>::into(e.to_string()))?;
        println!("number of SERVERS we got: {:#?}", servers.len());
        Ok(servers.into_iter().map(Dynamic::from).collect())
    }

    #[rhai_fn(name = "update_server_name", return_raw)]
    pub fn update_server_name(
        client: &mut Client,
        server_number: i64,
        name: &str,
    ) -> Result<Server, Box<EvalAltResult>> {
        client
            .update_server_name(server_number as i32, name)
            .map_err(|e| e.to_string().into())
    }

    #[rhai_fn(name = "get_cancellation_data", return_raw)]
    pub fn get_cancellation_data(
        client: &mut Client,
        server_number: i64,
    ) -> Result<Cancellation, Box<EvalAltResult>> {
        client
            .get_cancellation_data(server_number as i32)
            .map_err(|e| e.to_string().into())
    }

    #[rhai_fn(name = "cancel_server", return_raw)]
    pub fn cancel_server(
        client: &mut Client,
        server_number: i64,
        cancellation_date: &str,
    ) -> Result<Cancellation, Box<EvalAltResult>> {
        client
            .cancel_server(server_number as i32, cancellation_date)
            .map_err(|e| e.to_string().into())
    }

    #[rhai_fn(name = "withdraw_cancellation", return_raw)]
    pub fn withdraw_cancellation(
        client: &mut Client,
        server_number: i64,
    ) -> Result<(), Box<EvalAltResult>> {
        client
            .withdraw_cancellation(server_number as i32)
            .map_err(|e| e.to_string().into())
    }
}