wx_mini_api 0.1.27

use js_sys::*;
use serde::{Deserialize, Serialize};
use serde_wasm_bindgen::from_value;
use wasm_bindgen::prelude::*;
use wasm_bindgen_futures::JsFuture;

use crate::common::{ErrMsg, WxError};

#[wasm_bindgen]
extern "C" {
    #[wasm_bindgen(js_namespace = wx, js_name = switchTab)]
    fn switch_tab(params: &Object) -> bool;
    #[wasm_bindgen(js_namespace = wx, js_name = reLaunch)]
    fn re_launch(params: &Object) -> bool;
    #[wasm_bindgen(js_namespace = wx, js_name = redirectTo)]
    fn redirect_to(params: &Object) -> bool;
    #[wasm_bindgen(js_namespace = wx, js_name = navigateTo)]
    fn navigate_to(params: &Object) -> bool;
    #[wasm_bindgen(js_namespace = wx, js_name = navigateBack)]
    fn navigate_back(params: &Object) -> bool;
}

#[derive(Deserialize, Serialize, Debug, Default)]
pub struct RouterPath {
    url: String,
}
pub async fn wx_switch_tab<T: AsRef<str>>(url: T) -> Result<bool, WxError> {
    let params: Object = Object::new();
    Reflect::set(&params, &JsValue::from("url"), &JsValue::from(url.as_ref())).unwrap();

    let promise = Promise::new(&mut |resolve, reject| {
        let success_handler = move |_| -> Result<JsValue, JsValue> {
            let _ = resolve.call1(&JsValue::NULL, &JsValue::from(true));
            Ok(JsValue::NULL)
        };
        let success_handler = Closure::wrap(
            Box::new(success_handler) as Box<dyn Fn(JsValue) -> Result<JsValue, JsValue>>
        );

        let fail_handler = move |res| -> Result<JsValue, JsValue> {
            let _ = reject.call1(&JsValue::NULL, &res);
            Ok(JsValue::NULL)
        };
        let fail_handler = Closure::wrap(
            Box::new(fail_handler) as Box<dyn Fn(JsValue) -> Result<JsValue, JsValue>>
        );

        Reflect::set(&params, &JsValue::from("success"), success_handler.as_ref()).unwrap();
        success_handler.forget();
        Reflect::set(&params, &JsValue::from("fail"), fail_handler.as_ref()).unwrap();
        fail_handler.forget();

        switch_tab(&params);
    });
    let future = JsFuture::from(promise);
    match future.await {
        Ok(info) => Ok(from_value::<bool>(info).unwrap()),
        Err(err) => Err(WxError::WxErrMsg(from_value::<ErrMsg>(err).unwrap())),
    }
}

pub async fn wx_re_launch<T: AsRef<str>>(url: T) -> Result<bool, WxError> {
    let params: Object = Object::new();
    Reflect::set(&params, &JsValue::from("url"), &JsValue::from(url.as_ref())).unwrap();

    let promise = Promise::new(&mut |resolve, reject| {
        let success_handler = move |_| -> Result<JsValue, JsValue> {
            let _ = resolve.call1(&JsValue::NULL, &JsValue::from(true));
            Ok(JsValue::NULL)
        };
        let success_handler = Closure::wrap(
            Box::new(success_handler) as Box<dyn Fn(JsValue) -> Result<JsValue, JsValue>>
        );

        let fail_handler = move |res| -> Result<JsValue, JsValue> {
            let _ = reject.call1(&JsValue::NULL, &res);
            Ok(JsValue::NULL)
        };
        let fail_handler = Closure::wrap(
            Box::new(fail_handler) as Box<dyn Fn(JsValue) -> Result<JsValue, JsValue>>
        );

        Reflect::set(&params, &JsValue::from("success"), success_handler.as_ref()).unwrap();
        success_handler.forget();
        Reflect::set(&params, &JsValue::from("fail"), fail_handler.as_ref()).unwrap();
        fail_handler.forget();

        re_launch(&params);
    });
    let future = JsFuture::from(promise);
    match future.await {
        Ok(info) => Ok(from_value::<bool>(info).unwrap()),
        Err(err) => Err(WxError::WxErrMsg(from_value::<ErrMsg>(err).unwrap())),
    }
}

pub async fn wx_redirect_to<T: AsRef<str>>(url: T) -> Result<bool, WxError> {
    let params: Object = Object::new();
    Reflect::set(&params, &JsValue::from("url"), &JsValue::from(url.as_ref())).unwrap();

    let promise = Promise::new(&mut |resolve, reject| {
        let success_handler = move |_| -> Result<JsValue, JsValue> {
            let _ = resolve.call1(&JsValue::NULL, &JsValue::from(true));
            Ok(JsValue::NULL)
        };
        let success_handler = Closure::wrap(
            Box::new(success_handler) as Box<dyn Fn(JsValue) -> Result<JsValue, JsValue>>
        );

        let fail_handler = move |res| -> Result<JsValue, JsValue> {
            let _ = reject.call1(&JsValue::NULL, &res);
            Ok(JsValue::NULL)
        };
        let fail_handler = Closure::wrap(
            Box::new(fail_handler) as Box<dyn Fn(JsValue) -> Result<JsValue, JsValue>>
        );

        Reflect::set(&params, &JsValue::from("success"), success_handler.as_ref()).unwrap();
        success_handler.forget();
        Reflect::set(&params, &JsValue::from("fail"), fail_handler.as_ref()).unwrap();
        fail_handler.forget();

        redirect_to(&params);
    });
    let future = JsFuture::from(promise);
    match future.await {
        Ok(info) => Ok(from_value::<bool>(info).unwrap()),
        Err(err) => Err(WxError::WxErrMsg(from_value::<ErrMsg>(err).unwrap())),
    }
}

pub async fn wx_navigate_to<T: AsRef<str>>(url: T) -> Result<bool, WxError> {
    let params: Object = Object::new();
    Reflect::set(&params, &JsValue::from("url"), &JsValue::from(url.as_ref())).unwrap();

    let promise = Promise::new(&mut |resolve, reject| {
        let success_handler = move |_| -> Result<JsValue, JsValue> {
            let _ = resolve.call1(&JsValue::NULL, &JsValue::from(true));
            Ok(JsValue::NULL)
        };
        let success_handler = Closure::wrap(
            Box::new(success_handler) as Box<dyn Fn(JsValue) -> Result<JsValue, JsValue>>
        );

        let fail_handler = move |res| -> Result<JsValue, JsValue> {
            let _ = reject.call1(&JsValue::NULL, &res);
            Ok(JsValue::NULL)
        };
        let fail_handler = Closure::wrap(
            Box::new(fail_handler) as Box<dyn Fn(JsValue) -> Result<JsValue, JsValue>>
        );

        Reflect::set(&params, &JsValue::from("success"), success_handler.as_ref()).unwrap();
        success_handler.forget();
        Reflect::set(&params, &JsValue::from("fail"), fail_handler.as_ref()).unwrap();
        fail_handler.forget();

        navigate_to(&params);
    });
    let future = JsFuture::from(promise);
    match future.await {
        Ok(info) => Ok(from_value::<bool>(info).unwrap()),
        Err(err) => Err(WxError::WxErrMsg(from_value::<ErrMsg>(err).unwrap())),
    }
}

#[derive(Deserialize, Serialize, Debug, Default)]
pub struct RouterBack {
    delta: u8,
}
pub async fn wx_navigate_back(delta: u8) -> Result<bool, WxError> {
    let params: Object = Object::new();
    Reflect::set(&params, &JsValue::from("delta"), &JsValue::from(delta)).unwrap();

    let promise = Promise::new(&mut |resolve, reject| {
        let success_handler = move |_| -> Result<JsValue, JsValue> {
            let _ = resolve.call1(&JsValue::NULL, &JsValue::from(true));
            Ok(JsValue::NULL)
        };
        let success_handler = Closure::wrap(
            Box::new(success_handler) as Box<dyn Fn(JsValue) -> Result<JsValue, JsValue>>
        );

        let fail_handler = move |res| -> Result<JsValue, JsValue> {
            let _ = reject.call1(&JsValue::NULL, &res);
            Ok(JsValue::NULL)
        };
        let fail_handler = Closure::wrap(
            Box::new(fail_handler) as Box<dyn Fn(JsValue) -> Result<JsValue, JsValue>>
        );

        Reflect::set(&params, &JsValue::from("success"), success_handler.as_ref()).unwrap();
        success_handler.forget();
        Reflect::set(&params, &JsValue::from("fail"), fail_handler.as_ref()).unwrap();
        fail_handler.forget();

        navigate_back(&params);
    });
    let future = JsFuture::from(promise);
    match future.await {
        Ok(info) => Ok(from_value::<bool>(info).unwrap()),
        Err(err) => Err(WxError::WxErrMsg(from_value::<ErrMsg>(err).unwrap())),
    }
}