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 = requestPayment)]
    fn request_payment(params: &Object) -> bool;
}

#[derive(Deserialize, Serialize, Debug, PartialEq, Eq, Default)]
pub enum SignType {
    #[default]
    #[serde(rename = "MD5")]
    Md5,
    #[serde(rename = "HMAC-SHA256")]
    Sha256,
    #[serde(rename = "RSA")]
    Rsa,
}
#[derive(Deserialize, Serialize, Debug, Default)]
#[serde(rename_all = "camelCase")]
pub struct Payment<'a> {
    pub time_stamp: &'a str,
    pub nonce_str: &'a str,
    pub package: &'a str,
    pub pay_sign: &'a str,
    pub sign_type: Option<SignType>,
}
pub async fn wx_request_payment<'a>(data: Payment<'a>) -> Result<bool, WxError> {
    let params = Object::new();
    Reflect::set(
        &params,
        &JsValue::from("timeStamp"),
        &JsValue::from(data.time_stamp),
    )
    .unwrap();
    Reflect::set(
        &params,
        &JsValue::from("nonceStr"),
        &JsValue::from(data.nonce_str),
    )
    .unwrap();
    Reflect::set(
        &params,
        &JsValue::from("package"),
        &JsValue::from(data.package),
    )
    .unwrap();
    Reflect::set(
        &params,
        &JsValue::from("paySign"),
        &JsValue::from(data.pay_sign),
    )
    .unwrap();
    if let Some(v) = data.sign_type {
        let value = to_value(&v).unwrap();
        Reflect::set(&params, &JsValue::from("signType"), &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();

        request_payment(&params);
    });
    let future = JsFuture::from(promise);
    match future.await {
        Ok(_info) => {
            // from_value::<Response<T>>(info).unwrap();
            Ok(true)
        }
        Err(err) => Err(WxError::WxErrMsg(from_value::<ErrMsg>(err).unwrap())),
    }
}