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 = openSystemBluetoothSetting)]
    // fn open_system_bluetooth_setting(s: &str) -> bool;
    #[wasm_bindgen(js_namespace = wx, js_name = openAppAuthorizeSetting)]
    fn open_app_authorize_setting(params: &Object) -> bool;
    #[wasm_bindgen(js_namespace = wx, js_name = getWindowInfo)]
    fn get_window_info() -> JsValue;
    #[wasm_bindgen(js_namespace = wx, js_name = getSystemSetting)]
    fn get_system_setting() -> JsValue;
    #[wasm_bindgen(js_namespace = wx, js_name = getSkylineInfoSync)]
    fn get_sky_line_info_sync() -> JsValue;
    #[wasm_bindgen(js_namespace = wx, js_name = getDeviceInfo)]
    fn get_device_info() -> JsValue;
    #[wasm_bindgen(js_namespace = wx, js_name = getDeviceBenchmarkInfo)]
    fn get_device_benchmark_info(params: &Object) -> JsValue;
    #[wasm_bindgen(js_namespace = wx, js_name = getAppBaseInfo)]
    fn get_app_base_info() -> JsValue;
    #[wasm_bindgen(js_namespace = wx, js_name = getAppAuthorizeSetting)]
    fn get_app_authorize_setting() -> JsValue;
}

pub async fn wx_open_app_authorize_setting() -> Result<ErrMsg, WxError> {
    let params: Object = Object::new();

    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();

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

#[derive(Deserialize, Serialize, Debug, Default)]
pub struct SafeArea {
    pub bottom: u16,
    pub height: u16,
    pub left: u16,
    pub right: u16,
    pub top: u16,
    pub width: u16,
}
#[derive(Deserialize, Serialize, Debug, Default)]
#[serde(rename_all = "camelCase")]
pub struct WindowInfo {
    pub pixel_ratio: f32,
    pub screen_width: u16,
    pub screen_height: u16,
    pub window_width: u16,
    pub window_height: u16,
    pub status_bar_height: u16,
    pub screen_top: u16,
    pub safe_area: SafeArea,
}
pub fn wx_get_window_info() -> WindowInfo {
    let value = get_window_info();
    from_value::<WindowInfo>(value).unwrap()
}

#[derive(Deserialize, Serialize, Debug, PartialEq, Eq, Default)]
pub enum DeviceOrientation {
    #[default]
    #[serde(rename = "portrait")]
    Portrait,
    #[serde(rename = "landscape")]
    Landscape,
}
#[derive(Deserialize, Serialize, Debug, Default)]
#[serde(rename_all = "camelCase")]
pub struct SystemSetting {
    pub bluetooth_enabled: bool,
    pub location_enabled: bool,
    pub wifi_enabled: bool,
    pub device_orientation: DeviceOrientation,
}
pub fn wx_get_system_setting() -> SystemSetting {
    let value = get_system_setting();
    from_value::<SystemSetting>(value).unwrap()
}

#[derive(Deserialize, Serialize, Debug, Default)]
#[serde(rename_all = "camelCase")]
pub struct SkyLineInfo {
    pub is_supported: bool,
    pub version: String,
    pub reason: String,
}
pub fn wx_get_sky_line_info_sync() -> SkyLineInfo {
    let value = get_sky_line_info_sync();
    from_value::<SkyLineInfo>(value).unwrap()
}

#[derive(Deserialize, Serialize, Debug, Default)]
#[serde(rename_all = "camelCase")]
pub struct DeviceInfo {
    pub abi: String,
    pub device_abi: String,
    pub brand: String,
    pub model: String,
    pub system: String,
    pub platform: String,
    pub cpu_type: String,
    pub memory_size: String,
}
pub fn wx_get_device_info() -> DeviceInfo {
    let value = get_device_info();
    from_value::<DeviceInfo>(value).unwrap()
}

#[derive(Deserialize, Serialize, Debug, Default)]
#[serde(rename_all = "camelCase")]
pub struct DeviceBenchmarkInfo {
    pub benchmark_level: i16,
    pub model_level: u8,
}
pub async fn wx_get_device_benchmark_info() -> Result<DeviceBenchmarkInfo, WxError> {
    let params: Object = Object::new();

    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();

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

#[derive(Deserialize, Serialize, Debug, PartialEq, Eq, Default)]
pub enum AppTheme {
    #[default]
    #[serde(rename = "light")]
    Light,
    #[serde(rename = "dark")]
    Dark,
}
#[derive(Deserialize, Serialize, Debug, Default)]
pub struct AppBaseHost {
    app_id: String,
}
#[derive(Deserialize, Serialize, Debug, Default)]
#[serde(rename_all = "camelCase")]
pub struct AppBaseInfo {
    pub s_d_k_version: String,
    pub enable_debug: bool,
    pub host: AppBaseHost,
    pub language: String,
    pub version: String,
    pub theme: Option<AppTheme>,
    pub font_size_scale_factor: f32,
    pub font_size_setting: f32,
}
pub fn wx_get_app_base_info() -> AppBaseInfo {
    let value = get_app_base_info();
    from_value::<AppBaseInfo>(value).unwrap()
}

#[derive(Deserialize, Serialize, Debug, PartialEq, Eq, Default)]
pub enum AuthorizeType {
    #[serde(rename = "authorized")]
    Authorized,
    #[default]
    #[serde(rename = "denied")]
    Denied,
    #[serde(rename = "determined")]
    Determined,
}
#[derive(Deserialize, Serialize, Debug, Default)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizeSetting {
    pub album_authorized: AuthorizeType,
    pub bluetooth_authorized: AuthorizeType,
    pub camera_authorized: AuthorizeType,
    pub location_authorized: AuthorizeType,
    pub location_reduced_accuracy: bool,
    pub microphone_authorized: AuthorizeType,
    pub notification_authorized: AuthorizeType,
    pub notification_alert_authorized: AuthorizeType,
    pub notification_badge_authorized: AuthorizeType,
    pub notification_sound_authorized: AuthorizeType,
    pub phone_calendar_authorized: AuthorizeType,
}
pub fn wx_get_app_authorize_setting() -> AuthorizeSetting {
    let value = get_app_authorize_setting();
    from_value::<AuthorizeSetting>(value).unwrap()
}