use std::mem::transmute;

use crate::dynamic_data::{Battle, DynamicLibrary, LearnedMove, Pokemon};
use crate::script_implementations::wasm::export_registry::register;
use crate::script_implementations::wasm::extern_ref::ExternRef;
use crate::script_implementations::wasm::script_resolver::WebAssemblyEnv;
use crate::static_data::{ClampedStatisticSet, Species};
use crate::static_data::{Item, StatisticSet};
use wasmer::FunctionEnvMut;

register! {
    fn pokemon_get_library(
        env: FunctionEnvMut<WebAssemblyEnv>,
        pokemon: ExternRef<Pokemon>,
    ) -> ExternRef<DynamicLibrary> {
        let lib = pokemon.value_func(&env).unwrap().library();
        ExternRef::func_new(&env, lib)
    }

    fn pokemon_get_boosted_stats(
        env: FunctionEnvMut<WebAssemblyEnv>,
        pokemon: ExternRef<Pokemon>,
    ) -> ExternRef<StatisticSet<u32>> {
        let statistic_set = pokemon.value_func(&env).unwrap().boosted_stats();
        ExternRef::func_new(&env, statistic_set)
    }

    fn pokemon_get_flat_stats(
        env: FunctionEnvMut<WebAssemblyEnv>,
        pokemon: ExternRef<Pokemon>,
    ) -> ExternRef<StatisticSet<u32>> {
        let statistic_set = pokemon.value_func(&env).unwrap().flat_stats();
        ExternRef::func_new(&env, statistic_set)
    }

    fn pokemon_get_stat_boosts(
        env: FunctionEnvMut<WebAssemblyEnv>,
        pokemon: ExternRef<Pokemon>,
    ) -> ExternRef<ClampedStatisticSet<i8, -6, 6>> {
        let statistic_set = pokemon.value_func(&env).unwrap().stat_boosts();
        ExternRef::func_new(&env, statistic_set)
    }

    fn pokemon_get_individual_values(
        env: FunctionEnvMut<WebAssemblyEnv>,
        pokemon: ExternRef<Pokemon>,
    ) -> ExternRef<ClampedStatisticSet<u8, 0, 31>> {
        let statistic_set = pokemon.value_func(&env).unwrap().individual_values();
        ExternRef::func_new(&env, statistic_set)
    }

    fn pokemon_get_effort_values(
        env: FunctionEnvMut<WebAssemblyEnv>,
        pokemon: ExternRef<Pokemon>,
    ) -> ExternRef<ClampedStatisticSet<u8, 0, 252>> {
        let statistic_set = pokemon.value_func(&env).unwrap().effort_values();
        ExternRef::func_new(&env, statistic_set)
    }

    fn pokemon_get_species(
        env: FunctionEnvMut<WebAssemblyEnv>,
        pokemon: ExternRef<Pokemon>,
    ) -> ExternRef<Species> {
        let species = pokemon.value_func(&env).unwrap().species();
        ExternRef::func_new(&env, species)
    }

    fn pokemon_damage(
        env: FunctionEnvMut<WebAssemblyEnv>,
        pokemon: ExternRef<Pokemon>,
        damage: u32,
        source: u8
    ) {
        unsafe{
            pokemon.value_func(&env).unwrap().damage(damage, transmute(source));
        }
    }

    fn pokemon_get_learned_move(
        env: FunctionEnvMut<WebAssemblyEnv>,
        pokemon: ExternRef<Pokemon>,
        index: u32
    ) -> ExternRef<LearnedMove> {
        let read_lock = pokemon.value_func(&env).unwrap().learned_moves().read();
        let mv = read_lock.get(index as usize);
        if let Some(Some(mv)) = mv {
            ExternRef::func_new(&env, mv)
        }
        else{
            ExternRef::null()
        }
    }

    fn pokemon_change_stat_boost(
        env: FunctionEnvMut<WebAssemblyEnv>,
        pokemon: ExternRef<Pokemon>,
        stat: u8,
        amount: i8,
        self_inflicted: u8
    ) -> u8 {
        unsafe{
            if pokemon.value_func(&env).unwrap().change_stat_boost(transmute(stat), amount, self_inflicted == 1) {
                1
            } else {
                0
            }
        }
    }

    fn pokemon_get_battle(
        env: FunctionEnvMut<WebAssemblyEnv>,
        pokemon: ExternRef<Pokemon>,
    ) -> ExternRef<Battle> {
        if let Some(battle) = pokemon.value_func(&env).unwrap().get_battle() {
            ExternRef::func_new(&env, battle)
        } else {
            ExternRef::null()
        }
    }

    fn pokemon_get_battle_side_index(
        env: FunctionEnvMut<WebAssemblyEnv>,
        pokemon: ExternRef<Pokemon>,
    ) -> u8 {
        if let Some(i) = pokemon.value_func(&env).unwrap().get_battle_index() {
            i
        } else {
            0
        }
    }

    fn pokemon_get_held_item(
        env: FunctionEnvMut<WebAssemblyEnv>,
        pokemon: ExternRef<Pokemon>,
    ) -> ExternRef<Item> {
        let read_lock = pokemon.value_func(&env).unwrap().held_item().read();
        if let Some(item) = read_lock.as_ref() {
            ExternRef::func_new(&env, item.as_ref())
        } else {
            ExternRef::null()
        }
    }

}