wx_mini_api 0.1.27

use js_sys::*;
use serde::{Deserialize, Serialize};
use serde_wasm_bindgen::{from_value, to_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 = showToast)]
    fn show_toast(params: &Object);
    #[wasm_bindgen(js_namespace = wx, js_name = showModal)]
    fn show_modal(params: &Object) -> JsValue;
    #[wasm_bindgen(js_namespace = wx, js_name = showLoading)]
    fn show_loading(params: &Object);
    #[wasm_bindgen(js_namespace = wx, js_name = showActionSheet)]
    fn show_action_sheet(params: &Object) -> JsValue;
    #[wasm_bindgen(js_namespace = wx, js_name = hideToast)]
    fn hide_toast();
    #[wasm_bindgen(js_namespace = wx, js_name = hideLoading)]
    fn hide_loading();
}

#[derive(Deserialize, Serialize, Debug, PartialEq, Eq, Default)]
pub enum ShowToastIcon {
    #[default]
    #[serde(rename = "success")]
    Success,
    #[serde(rename = "error")]
    Error,
    #[serde(rename = "loading")]
    Loading,
    #[serde(rename = "none")]
    None,
}
#[derive(Deserialize, Serialize, Debug, Default)]
#[serde(rename_all = "camelCase")]
pub struct ShowToast<'a> {
    pub title: &'a str,
    pub icon: Option<ShowToastIcon>,
    pub image: Option<&'a str>,
    pub duration: Option<u16>,
    pub mask: Option<bool>,
}
pub fn wx_show_toast<'a>(data: ShowToast<'a>) {
    let params = Object::new();
    Reflect::set(&params, &JsValue::from("title"), &JsValue::from(data.title)).unwrap();
    if let Some(v) = data.icon {
        let value = to_value(&v).unwrap();
        Reflect::set(&params, &JsValue::from("icon"), &value).unwrap();
    }
    if let Some(v) = data.image {
        let value = to_value(v).unwrap();
        Reflect::set(&params, &JsValue::from("image"), &value).unwrap();
    }
    if let Some(v) = data.duration {
        let value = to_value(&v).unwrap();
        Reflect::set(&params, &JsValue::from("duration"), &value).unwrap();
    }
    if let Some(v) = data.mask {
        let value = to_value(&v).unwrap();
        Reflect::set(&params, &JsValue::from("mask"), &value).unwrap();
    }

    show_toast(&params);
}

#[derive(Deserialize, Serialize, Debug, Default)]
#[serde(rename_all = "camelCase")]
pub struct ShowModal<'a> {
    pub title: Option<&'a str>,
    pub content: Option<&'a str>,
    pub show_cancel: Option<bool>,
    pub cancel_text: Option<&'a str>,
    pub cancel_color: Option<&'a str>,
    pub confirm_text: Option<&'a str>,
    pub confirm_color: Option<&'a str>,
    pub editable: Option<bool>,
    pub placeholder_text: Option<&'a str>,
}
#[derive(Deserialize, Serialize, Debug, Default)]
#[serde(rename_all = "camelCase")]
pub struct ShowModalRes {
    pub content: Option<String>,
    pub confirm: bool,
    pub cancel: bool,
}
pub async fn wx_show_modal<'a>(data: ShowModal<'a>) -> Result<ShowModalRes, WxError> {
    let params = Object::new();
    if let Some(v) = data.title {
        let value = to_value(v).unwrap();
        Reflect::set(&params, &JsValue::from("title"), &value).unwrap();
    }
    if let Some(v) = data.content {
        let value = to_value(v).unwrap();
        Reflect::set(&params, &JsValue::from("content"), &value).unwrap();
    }
    if let Some(v) = data.show_cancel {
        let value = to_value(&v).unwrap();
        Reflect::set(&params, &JsValue::from("showCancel"), &value).unwrap();
    }
    if let Some(v) = data.cancel_text {
        let value = to_value(v).unwrap();
        Reflect::set(&params, &JsValue::from("cancelText"), &value).unwrap();
    }
    if let Some(v) = data.cancel_color {
        let value = to_value(v).unwrap();
        Reflect::set(&params, &JsValue::from("cancelColor"), &value).unwrap();
    }
    if let Some(v) = data.confirm_text {
        let value = to_value(v).unwrap();
        Reflect::set(&params, &JsValue::from("confirmText"), &value).unwrap();
    }
    if let Some(v) = data.confirm_color {
        let value = to_value(v).unwrap();
        Reflect::set(&params, &JsValue::from("confirmColor"), &value).unwrap();
    }
    if let Some(v) = data.editable {
        let value = to_value(&v).unwrap();
        Reflect::set(&params, &JsValue::from("editable"), &value).unwrap();
    }
    if let Some(v) = data.placeholder_text {
        let value = to_value(v).unwrap();
        Reflect::set(&params, &JsValue::from("placeholderText"), &value).unwrap();
    }

    let promise = Promise::new(&mut |resolve, reject| {
        let success_handler = move |res| -> Result<JsValue, JsValue> {
            let _ = resolve.call1(&JsValue::NULL, &res);
            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();

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

#[derive(Deserialize, Serialize, Debug, Default)]
#[serde(rename_all = "camelCase")]
pub struct ShowLoading<'a> {
    pub title: &'a str,
    pub mask: Option<bool>,
}
pub fn wx_show_loading<'a>(data: ShowLoading<'a>) {
    let params = Object::new();
    Reflect::set(&params, &JsValue::from("title"), &JsValue::from(data.title)).unwrap();
    if let Some(v) = data.mask {
        let value = to_value(&v).unwrap();
        Reflect::set(&params, &JsValue::from("mask"), &value).unwrap();
    }
}

#[derive(Deserialize, Serialize, Debug, Default)]
#[serde(rename_all = "camelCase")]
pub struct ShowActionSheet<'a> {
    pub alert_text: Option<&'a str>,
    pub item_list: Vec<&'a str>,
    pub item_color: Option<&'a str>,
}
#[derive(Deserialize, Serialize, Debug, Default)]
#[serde(rename_all = "camelCase")]
pub struct ShowActionSheetRes {
    pub tap_index: Option<u8>,
}
pub async fn wx_show_action_sheet<'a>(
    data: ShowActionSheet<'a>,
) -> Result<ShowActionSheetRes, WxError> {
    let params = Object::new();
    let jsvalue = to_value(&data.item_list).unwrap();
    Reflect::set(&params, &JsValue::from("itemList"), &JsValue::from(jsvalue)).unwrap();
    if let Some(v) = data.alert_text {
        let value = to_value(v).unwrap();
        Reflect::set(&params, &JsValue::from("alertText"), &value).unwrap();
    }
    if let Some(v) = data.item_color {
        let value = to_value(v).unwrap();
        Reflect::set(&params, &JsValue::from("itemColor"), &value).unwrap();
    }
    let promise = Promise::new(&mut |resolve, reject| {
        let success_handler = move |res| -> Result<JsValue, JsValue> {
            let _ = resolve.call1(&JsValue::NULL, &res);
            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();

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

pub fn wx_hide_toast() {
    hide_toast();
}

pub fn wx_hide_loading() {
    hide_loading();
}