// a.rs
#[derive(Tsify)]
pub struct Foo {
    pub n: usize,
}

// b.rs
#[derive(Tsify)]
pub struct Foo {
    pub s: String,
}

/// JSON-compatible and human readable format of transactions. E.g. addresses are presented in their human-readable
/// format and address types and the network are represented as strings. Data and proof are serialized as an object
/// describing their contents.
#[derive(serde::Serialize, serde::Deserialize, Tsify)]
#[serde(rename_all = "camelCase")]
pub struct PlainTransaction {
    /// The transaction's unique hash, used as its identifier. Sometimes also called `txId`.
    pub transaction_hash: String,

    // [...]
}

#[derive(Debug, Serialize, Deserialize, Tsify)]
#[serde(tag = "reason")]
pub enum ParseBaseUriError {
    MissingTrailingSlash,
    UrlParseError(String),
    CannotBeABase,
}

use std::sync::Arc;

use js_sys::Promise;
use serde::{Deserialize, Serialize};
use tokio::sync::RwLock;
use wasm_bindgen::prelude::*;
use wasm_bindgen_futures::future_to_promise;

extern crate web_sys;

// A macro to provide `println!(..)`-style syntax for `console.log` logging.
#[macro_export]
macro_rules! console_log {
    ( $( $t:tt )* ) => {
        web_sys::console::log_1(&format!( $( $t )* ).into());
    }
}

#[wasm_bindgen]
pub struct MyApi {
    pub(crate) api: Arc<tokio::sync::RwLock<ApiImpl>>,
}

#[wasm_bindgen]
pub struct ApiImpl {
    pub(crate) name: String,
    pub(crate) some_stuff: Arc<tokio::sync::RwLock<u32>>,
}

#[wasm_bindgen]
impl ApiImpl {
    pub fn new(name: String) -> Self {
        Self {
            name,
            some_stuff: Arc::new(RwLock::new(0)),
        }
    }

    pub fn get_name(&self) -> String {
        self.name.clone()
    }

    pub async fn do_stuff(&self) -> u32 {
        let mut some_stuff = self.some_stuff.write().await;
        *some_stuff += 1;
        *some_stuff
    }

    pub async fn get_stuff(&self) -> u32 {
        let some_stuff = self.some_stuff.read().await;
        *some_stuff
    }

    pub fn add_game_to_cart(
        &mut self,
        game_item_dbid: Gid,
        // game_group_dbid: Option<Gid>,
        // source: PlayerActionSource,
    ) -> Result<String, String> {
        if game_item_dbid.data == 0 {
            Err("game_group_dbid is none".to_string())
        } else {
            Ok("ok".to_string())
        }
    }
}

#[wasm_bindgen]
impl MyApi {
    pub fn new(name: String) -> Self {
        Self {
            api: Arc::new(RwLock::new(ApiImpl::new(name))),
        }
    }

    pub async fn get_name(&self) -> String {
        let api = self.api.read().await;
        api.get_name()
    }

    pub async fn do_stuff(&self) -> u32 {
        let mut api = self.api.write().await;
        api.do_stuff().await
    }

    pub async fn get_stuff(&self) -> u32 {
        let api = self.api.read().await;
        console_log!("get_stuff");
        api.get_stuff().await
    }

    pub fn add_game_to_cart(
        &mut self,
        game_item_dbid: Gid,
        // game_group_dbid: Option<Gid>,
        // source: PlayerActionSource,
    ) -> Promise {
        console_log!("add_game_to_cart");
        let api = self.api.clone();
        console_log!("add_game_to_cart");
        future_to_promise(async move {
            let mut api = api.write().await;
            let result = api
                .add_game_to_cart(game_item_dbid) //, game_group_dbid, source)
                .to_js_result()?;
            let serializer = serde_wasm_bindgen::Serializer::json_compatible();
            let result = result.serialize(&serializer);
            Ok(result?)
        })
    }
}

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, tsify::Tsify)]
#[tsify(from_wasm_abi)]
#[serde(tag = "kind", content = "payload")]
#[serde(rename_all = "snake_case")]
pub enum PlayerActionSource {
    Unknown,
    Aig,
    Navigation,
    Search { search_string: String },
}

#[derive(
    Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Debug, Clone, serde::Serialize, serde::Deserialize,
)]
#[cfg_attr(
    any(target_arch = "wasm32", target_os = "macos"),
    derive(tsify::Tsify),
    tsify(from_wasm_abi, into_wasm_abi)
)]
pub struct Gid {
    pub data: u128,
}

use wasm_bindgen::JsValue;

pub type JsResult<T> = Result<T, JSError>;

pub trait ToJSResultTrait<T>: Sized {
    fn to_js_result(self) -> JsResult<T>;

    fn to_js_result_msg(self, msg: &str) -> JsResult<T> {
        match self.to_js_result() {
            Ok(value) => Ok(value),
            Err(err) => Err(JSError {
                message: format!("{}: {}", msg, err.message),
            }),
        }
    }
}

impl<T> ToJSResultTrait<T> for Option<T> {
    fn to_js_result(self) -> JsResult<T> {
        match self {
            Some(value) => Ok(value),
            None => Err(JSError {
                message: "Option is None".to_string(),
            }),
        }
    }
}

impl<T> ToJSResultTrait<T> for Result<T, String> {
    fn to_js_result(self) -> JsResult<T> {
        match self {
            Ok(value) => Ok(value),
            Err(err) => Err(JSError { message: err }),
        }
    }
}

impl<T> ToJSResultTrait<T> for Result<T, reqwest::Error> {
    fn to_js_result(self) -> JsResult<T> {
        match self {
            Ok(value) => Ok(value),
            Err(err) => Err(JSError {
                message: err.to_string(),
            }),
        }
    }
}

impl From<JSError> for JsValue {
    fn from(error: JSError) -> JsValue {
        serde_wasm_bindgen::to_value(&error).unwrap()
    }
}

use wasm_bindgen::prelude::wasm_bindgen;

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, tsify::Tsify)]
#[tsify(from_wasm_abi)]
pub struct JSError {
    pub message: String,
}

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, tsify::Tsify)]
#[tsify(from_wasm_abi)]
pub struct JSAnalyticItem {
    pub order_id: String,
    pub action_type: String,
    pub test_id: Option<i16>,
    pub object: Option<String>,
}

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, tsify::Tsify)]
#[tsify(from_wasm_abi)]
#[serde(tag = "variant", content = "data")]
#[serde(rename_all = "snake_case")]
pub enum JSStreamStatus {
    Start,
    Retry(i8),
    GiveUp,
    Error(String),
}

use serde::{Deserialize, Serialize};
use tsify::Tsify;
use wasm_bindgen::prelude::*;

#[derive(Tsify, Serialize, Deserialize)]
#[tsify(into_wasm_abi, from_wasm_abi)]
pub struct Point {
    x: i32,
    y: i32,
}

#[wasm_bindgen]
pub async fn into_js() -> Point {
    Point { x: 0, y: 0 }
}

#[wasm_bindgen]
pub fn from_js(point: Point) {}

#[allow(dead_code)]
pub fn into_js() -> Point { Point { x: 0, y: 0 } }
#[automatically_derived]
const _: () =
    {
        pub unsafe extern "C" fn __wasm_bindgen_generated_into_js()
            -> <Point as wasm_bindgen::convert::ReturnWasmAbi>::Abi {
            let _ret = { let _ret = into_js(); _ret };
            <Point as wasm_bindgen::convert::ReturnWasmAbi>::return_abi(_ret)
        }
    };

#[allow(dead_code)]
pub async fn into_js() -> Point { Point { x: 0, y: 0 } }
#[automatically_derived]
const _: () =
    {
        pub unsafe extern "C" fn __wasm_bindgen_generated_into_js()
            ->
                <wasm_bindgen::JsValue as
                wasm_bindgen::convert::ReturnWasmAbi>::Abi {
            let _ret =
                wasm_bindgen_futures::future_to_promise(async move
                            {
                            {
                                let _ret = into_js();
                                <Point as
                                        wasm_bindgen::__rt::IntoJsResult>::into_js_result(_ret.await)
                            }
                        }).into();
            <wasm_bindgen::JsValue as
                    wasm_bindgen::convert::ReturnWasmAbi>::return_abi(_ret)
        }
    };

use tsify::Tsify;
use serde::Deserialize;

#[derive(Deserialize, Tsify)]
#[tsify(into_wasm_abi)]
#[serde(rename_all(serialize = "camelCase"))
struct MyStruct {
    should_be_camel_in_ts: i32
}

#[test]
fn test_flatten_optional() {
    #[derive(Tsify)]
    struct A {
        a: i32,
        b: String,
    }

    #[derive(Tsify)]
    struct B {
        #[tsify(optional)]
        #[serde(flatten)]
        extra: Option<A>,
        c: i32,
    }

    assert_eq!(
        B::DECL,
        indoc! {""}
    );
}

#[wasm_bindgen]
modify_some_object(my_wasm_obj: &mut MyWasmObj); 

#[derive(Debug, Serialize, Deserialize, Tsify)]
#[serde(tag = "reason", content = "inner")]
pub enum ParseBaseUriError {
    MissingTrailingSlash,
    ...
}

#[derive(Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum Foo {
  Bar,
  Qux,
  #[serde(untagged)]
  Other(f64),
}

use wasm_bindgen::prelude::*;

#[derive(serde::Deserialize, tsify::Tsify)]
#[tsify(from_wasm_abi)]
pub struct Foo {
    bar: Bar,
}

#[derive(serde::Deserialize, tsify::Tsify)]
#[tsify(from_wasm_abi)]
pub struct Bar {
    inner: String,
}

#[wasm_bindgen]
impl Bar {
    pub fn foobar(self) -> bool {
        true
    }
}

#[wasm_bindgen]
pub fn foo(foo: Foo) {}

#[derive(Debug, Clone, Serialize, Deserialize, Tsify)]
#[serde(rename = "foo")]
pub struct Foo {
  x: i32,
}


#[derive(Debug, Clone, Serialize, Deserialize, Tsify)]
pub struct Bar {
  foo: Foo,
}

use serde::{Serialize, Deserialize};
use tsify::Tsify;
#[derive(Serialize, Deserialize, Tsify)]
#[tsify(from_wasm_abi, into_wasm_abi)]
pub struct OneX {
    #[serde(rename = "1x")]
    pub one_x: f64;
}

use tsify::Tsify;
use serde::{Serialize, Deserialize};

#[derive(Tsify)]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct OneOf<T> {
    one_of: Vec<T>,
}

#[derive(Tsify)]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Bar {}

#[derive(Tsify)]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum Foo {
    OneOfFoo(OneOf<Foo>),
    Bar(Bar),
}

#[derive(serde::Serialize, tsify::Tsify)]
#[tsify(into_wasm_abi)]
pub struct ThingCollection(Vec<Thing>);

pub fn get_numbers() -> ThingCollection {
   ThingCollection(vec![Thing(1), Thing(2), Thing(3)])
}

#[derive(serde::Serialize, tsify::Tsify)]
#[tsify(into_wasm_abi)]
pub struct GenericCollection<T: IntoWasmAbi>(Vec<T>);

#[wasm_bindgen(js_class = MyTypeHandle)]
struct MyType {
    #[wasm_bindgen(js_name = getThings)]
    pub fn get_things(&self) -> GenericCollection<Thing> {
        let things = ...;
        GenericCollection(things)
    }
}

pub struct Color {
  r: i8,
  g: i8,
  b: i8,
}

-        impl From<JsType> for JsValue {
-            #[inline]
-            fn from(obj: JsType) -> JsValue {
-                obj.obj.into()
-            }
-        }
-        impl JsCast for JsType {
-        ...
-        }

#[derive(Clone, Debug)]
#[derive(tsify::Tsify, serde::Serialize)]
#[tsify(into_wasm_abi)]
pub struct ExampleType {
    pub name: Option<String>,
}

#[wasm_bindgen(js_class = ExampleTypeHandleJs)]
impl ExampleTypeHandle {
    #[wasm_bindgen(js_name = getExampleTypeVec)]
    pub fn get_example_type_vec(&self) -> Option<ExampleTypeVec> {
        todo!()
    }
}

#[derive(Tsify, Serialize)]
#[tsify(into_wasm_abi)]
pub struct ExampleTypeVec(pub Vec<ExampleType>);

    #[wasm_bindgen(js_name = getExampleType)]
    pub fn get_example_type(&self) -> ExampleType {
        todo!()
    }

#[derive(Clone, Debug)]
#[derive(tsify::Tsify, serde::Serialize, serde::Deserialize)]
#[tsify(into_wasm_abi, from_wasm_abi)]
pub struct ExampleType {
    pub name: Option<String>,
}

#[derive(Tsify)]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Foo<T> {
    #[tsify(type = "[T, ...T[]]")]
    bar: Vec<T>,
}