use wasm_bindgen::prelude::*;
use wasm_bindgen::Clamped;
use wasm_bindgen_test::*;

#[wasm_bindgen(module = "tests/wasm/slice.js")]
extern "C" {
    fn js_export();

    fn js_import();

    fn js_pass_array();

    fn js_export_mut();

    fn js_return_vec();

    fn js_clamped(val: Clamped<&[u8]>, offset: u8);
    #[wasm_bindgen(js_name = js_clamped)]
    fn js_clamped2(val: Clamped<Vec<u8>>, offset: u8);
    #[wasm_bindgen(js_name = js_clamped)]
    fn js_clamped3(val: Clamped<&mut [u8]>, offset: u8);
}

macro_rules! export_macro {
    ($(($i:ident, $n:ident))*) => ($(
        #[wasm_bindgen]
        pub fn $n(a: &[$i]) -> Vec<$i> {
            assert_eq!(a.len(), 2);
            assert_eq!(a[0], 1 as $i);
            assert_eq!(a[1], 2 as $i);
            a.to_vec()
        }
    )*)
}

export_macro! {
    (i8, export_i8)
    (u8, export_u8)
    (i16, export_i16)
    (u16, export_u16)
    (i32, export_i32)
    (u32, export_u32)
    (isize, export_isize)
    (usize, export_usize)
    (f32, export_f32)
    (f64, export_f64)
}

#[wasm_bindgen_test]
fn export() {
    js_export();
}

macro_rules! import_macro {
    ($(($rust:ident, $js:ident, $i:ident))*) => ($(
        #[wasm_bindgen(module = "tests/wasm/slice.js")]
        extern "C" {
            fn $js(a: &[$i], b: Option<&[$i]>, c: Option<&[$i]>) -> Vec<$i>;
        }

        #[wasm_bindgen]
        pub fn $rust(a: &[$i]) -> Vec<$i> {
            assert_eq!(a.len(), 2);
            assert_eq!(a[0], 1 as $i);
            assert_eq!(a[1], 2 as $i);
            $js(a, Some(a), None)
        }
    )*)
}

import_macro! {
    (import_rust_i8, import_js_i8, i8)
    (import_rust_u8, import_js_u8, u8)
    (import_rust_i16, import_js_i16, i16)
    (import_rust_u16, import_js_u16, u16)
    (import_rust_i32, import_js_i32, i32)
    (import_rust_u32, import_js_u32, u32)
    (import_rust_isize, import_js_isize, isize)
    (import_rust_usize, import_js_usize, usize)
    (import_rust_f32, import_js_f32, f32)
    (import_rust_f64, import_js_f64, f64)
}

#[wasm_bindgen_test]
fn import() {
    js_import();
}

macro_rules! pass_array_marco {
    ($(($rust:ident, $i:ident))*) => ($(
        #[wasm_bindgen]
        pub fn $rust(a: &[$i]) {
            assert_eq!(a.len(), 2);
            assert_eq!(a[0], 1 as $i);
            assert_eq!(a[1], 2 as $i);
        }
    )*)
}

pass_array_marco! {
    (pass_array_rust_i8, i8)
    (pass_array_rust_u8, u8)
    (pass_array_rust_i16, i16)
    (pass_array_rust_u16, u16)
    (pass_array_rust_i32, i32)
    (pass_array_rust_u32, u32)
    (pass_array_rust_isize, isize)
    (pass_array_rust_usize, usize)
    (pass_array_rust_f32, f32)
    (pass_array_rust_f64, f64)
}

#[wasm_bindgen_test]
fn pass_array() {
    js_pass_array();
}

macro_rules! import_mut_macro {
    ($(($rust:ident, $js:ident, $i:ident))*) => (
        $(
            #[wasm_bindgen(module = "tests/wasm/slice.js")]
            extern "C" {
                fn $js(a: &mut [$i], b: Option<&mut [$i]>, c: Option<&mut [$i]>);
            }

            fn $rust() {
                let mut buf1 = [
                    1 as $i,
                    2 as $i,
                    3 as $i,
                ];
                let mut buf2 = [
                    4 as $i,
                    5 as $i,
                    6 as $i,
                ];
                $js(&mut buf1, Some(&mut buf2), None);
                assert_eq!(buf1[0], 4 as $i);
                assert_eq!(buf1[1], 5 as $i);
                assert_eq!(buf1[2], 3 as $i);
                assert_eq!(buf2[0], 8 as $i);
                assert_eq!(buf2[1], 7 as $i);
                assert_eq!(buf2[2], 6 as $i);
            }
        )*

        #[wasm_bindgen_test]
        fn import_mut() {
            $($rust();)*
        }
    )
}

import_mut_macro! {
    (import_mut_rust_i8, import_mut_js_i8, i8)
    (import_mut_rust_u8, import_mut_js_u8, u8)
    (import_mut_rust_i16, import_mut_js_i16, i16)
    (import_mut_rust_u16, import_mut_js_u16, u16)
    (import_mut_rust_i32, import_mut_js_i32, i32)
    (import_mut_rust_u32, import_mut_js_u32, u32)
    (import_mut_rust_f32, import_mut_js_f32, f32)
    (import_mut_rust_f64, import_mut_js_f64, f64)
}

macro_rules! export_mut_macro {
    ($(($i:ident, $n:ident))*) => ($(
        #[wasm_bindgen]
        pub fn $n(a: &mut [$i])  {
            assert_eq!(a.len(), 3);
            assert_eq!(a[0], 1 as $i);
            assert_eq!(a[1], 2 as $i);
            assert_eq!(a[2], 3 as $i);
            a[0] = 4 as $i;
            a[1] = 5 as $i;
        }
    )*)
}

export_mut_macro! {
    (i8, export_mut_i8)
    (u8, export_mut_u8)
    (i16, export_mut_i16)
    (u16, export_mut_u16)
    (i32, export_mut_i32)
    (u32, export_mut_u32)
    (isize, export_mut_isize)
    (usize, export_mut_usize)
    (f32, export_mut_f32)
    (f64, export_mut_f64)
}

#[wasm_bindgen_test]
fn export_mut() {
    js_export_mut();
}

#[wasm_bindgen]
pub fn return_vec_broken_vec() -> Vec<u32> {
    vec![1, 2, 3, 4, 5, 6, 7, 8, 9]
}

#[wasm_bindgen]
pub fn return_vec_web_main() -> ReturnVecApplication {
    ReturnVecApplication::new()
}

#[wasm_bindgen]
pub struct ReturnVecApplication {
    thing: Vec<u32>,
}

#[wasm_bindgen]
impl ReturnVecApplication {
    pub fn new() -> ReturnVecApplication {
        let mut thing = vec![];
        thing.push(0);
        thing.push(0);
        thing.push(0);
        thing.push(0);
        thing.push(0);

        ReturnVecApplication { thing }
    }

    pub fn tick(&mut self) {
        self.thing = self.thing.clone();
    }
}

#[wasm_bindgen_test]
fn return_vec() {
    js_return_vec();
}

#[wasm_bindgen_test]
fn take_clamped() {
    js_clamped(Clamped(&[1, 2, 3]), 1);
    js_clamped2(Clamped(vec![4, 5, 6]), 4);
    js_clamped3(Clamped(&mut [7, 8, 9]), 7);
}