/*
 * Tencent is pleased to support the open source community by making Puerts available.
 * Copyright (C) 2020 THL A29 Limited, a Tencent company.  All rights reserved.
 * Puerts is licensed under the BSD 3-Clause License, except for the third-party components listed in the file 'LICENSE' which may
 * be subject to their corresponding license terms. This file is subject to the terms and conditions defined in file 'LICENSE',
 * which is part of this source code package.
 */

#pragma once
#include "wasm3.h"
#include "m3_env.h"
#include "WasmCommonIncludes.h"
#include "Wasm3ExportDef.h"

typedef uint64_t* wasm_stack_type;
typedef void* wasm_mem_type;

template <typename T>
struct wasm_remove_const_ref
{
    using type = typename std::remove_const<typename std::remove_reference<T>::type>::type;
};

template <bool V>
struct true_false_type
{
    static constexpr bool value = V;
};

template <typename T, typename Enable = void>
struct _wasm_is_simple_type;

//定义简单的类型,该类型会直接被放在栈上
template <>
struct _wasm_is_simple_type<bool> : true_false_type<true>
{
};
// template<> struct _wasm_is_simple_type<char> : true_false_type<true> {};
// template<> struct _wasm_is_simple_type<unsigned char> : true_false_type<true> {};
template <>
struct _wasm_is_simple_type<int32> : true_false_type<true>
{
};
template <>
struct _wasm_is_simple_type<uint32> : true_false_type<true>
{
};
template <>
struct _wasm_is_simple_type<int64> : true_false_type<true>
{
};
template <>
struct _wasm_is_simple_type<uint64> : true_false_type<true>
{
};
template <>
struct _wasm_is_simple_type<float> : true_false_type<true>
{
};
template <>
struct _wasm_is_simple_type<double> : true_false_type<true>
{
};
// enum为true,非enum为false
template <typename T>
struct _wasm_is_simple_type<T, typename std::enable_if<std::is_enum<T>::value>::type> : true_false_type<true>
{
};
template <typename T>
struct _wasm_is_simple_type<T, typename std::enable_if<!std::is_enum<T>::value>::type> : true_false_type<false>
{
};

template <typename T>
struct wasm_is_simple_type
{
    static constexpr bool value = _wasm_is_simple_type<typename wasm_remove_const_ref<T>::type>::value;
};

static_assert(wasm_is_simple_type<const int&>::value, "");
static_assert(wasm_is_simple_type<int&>::value, "");
static_assert(wasm_is_simple_type<int>::value, "");
static_assert(wasm_is_simple_type<const int>::value, "");
static_assert(!wasm_is_simple_type<void*>::value, "");

//定义复杂类型,该类型会被当作指针放在栈上
template <typename T>
struct _wasm_is_complex_type
{
    //这里有点奇怪
    // 属性数量大于1的结构体当指针
    // 小于32的结构体当int32,小于64的结构体当int64,大于64的当指针
    // 我们判断不了属性数量，所以强制规定,结构体必须大于64
    static constexpr bool value =
        !wasm_is_simple_type<T>::value && std::is_class<T>::value && std::is_trivially_copyable<T>::value && (sizeof(T) > 8);
};

template <typename T>
struct wasm_is_complex_type
{
    static constexpr bool value = _wasm_is_complex_type<typename wasm_remove_const_ref<T>::type>::value;
};
template <>
struct wasm_is_complex_type<void>
{
    static constexpr bool value = false;
};

static_assert(!wasm_is_complex_type<void*>::value, "");

template <typename T>
struct wasm_is_support_pointer_type
{
    using No_PTr = typename std::remove_pointer<T>::type;
    static constexpr bool value =
        std::is_pointer<T>::value && !wasm_is_complex_type<No_PTr>::value && !wasm_is_simple_type<No_PTr>::value;
};

template <typename... Args>
struct wasm_is_all_support_type;

template <typename T>
struct wasm_is_all_support_type<T>
{
    static constexpr bool value =
        wasm_is_complex_type<T>::value || wasm_is_simple_type<T>::value || wasm_is_support_pointer_type<T>::value;
};

template <typename T, typename... Args>
struct wasm_is_all_support_type<T, Args...>
{
    static constexpr bool value = wasm_is_all_support_type<T>::value && wasm_is_all_support_type<Args...>::value;
};

template <typename T, typename Enabled = void>
struct _wasm_call_params_translator
{
};

template <>
struct _wasm_call_params_translator<float>
{
    using type = float;
};

template <>
struct _wasm_call_params_translator<double>
{
    using type = double;
};

template <typename T>
struct _wasm_call_params_translator<T, typename std::enable_if<wasm_is_simple_type<T>::value && (sizeof(T) <= 4)>::type>
{
    using type = int32;
};

template <typename T>
struct _wasm_call_params_translator<T,
    typename std::enable_if<wasm_is_simple_type<T>::value && (sizeof(T) > 4) && (sizeof(T) <= 8)>::type>
{
    using type = int64;
};

template <typename T>
struct _wasm_call_params_translator<T, typename std::enable_if<wasm_is_complex_type<T>::value>::type>
{
    using type = WASM_PTR;
};

template <typename T>
struct _wasm_call_params_translator<T, typename std::enable_if<wasm_is_support_pointer_type<T>::value>::type>
{
    using type = WASM_PTR;
};

template <typename T>
struct wasm_call_params_translator
{
    using translated_type = typename _wasm_call_params_translator<typename wasm_remove_const_ref<T>::type>::type;
};

template <typename T, typename U>
using is_enum_of_t = typename std::enable_if<std::is_enum<T>::value && std::is_same<std::underlying_type_t<T>, U>::value>::type;

template <char c>
struct m3_sig
{
    static const char value = c;
};
template <typename T, typename = void>
struct _m3_type_to_sig;

template <typename T>
struct _m3_type_to_sig<T, is_enum_of_t<T, int32_t>> : m3_sig<'i'>
{
};

template <class T>
struct _m3_type_to_sig<T, is_enum_of_t<T, int64_t>> : m3_sig<'I'>
{
};

template <>
struct _m3_type_to_sig<bool> : m3_sig<'i'>
{
};
template <>
struct _m3_type_to_sig<char> : m3_sig<'i'>
{
};
template <>
struct _m3_type_to_sig<unsigned char> : m3_sig<'i'>
{
};
template <>
struct _m3_type_to_sig<int32_t> : m3_sig<'i'>
{
};
template <>
struct _m3_type_to_sig<uint32_t> : m3_sig<'i'>
{
};
template <>
struct _m3_type_to_sig<int64_t> : m3_sig<'I'>
{
};
template <>
struct _m3_type_to_sig<uint64_t> : m3_sig<'I'>
{
};
template <>
struct _m3_type_to_sig<float> : m3_sig<'f'>
{
};
template <>
struct _m3_type_to_sig<double> : m3_sig<'F'>
{
};
template <>
struct _m3_type_to_sig<void> : m3_sig<'v'>
{
};
template <typename T>
struct _m3_type_to_sig<T, typename std::is_reference<T>::type> : m3_sig<'*'>
{
};
template <typename T>
struct _m3_type_to_sig<T, typename std::enable_if<wasm_is_complex_type<T>::value>::type> : m3_sig<'*'>
{
};
template <typename T>
struct _m3_type_to_sig<T, typename std::enable_if<wasm_is_support_pointer_type<T>::value>::type> : m3_sig<'*'>
{
};

template <typename T, typename Enable = void>
struct m3_type_to_sig;

//引用当指针处理
template <typename T>
struct m3_type_to_sig<T, typename std::enable_if<std::is_reference<T>::value>::type>
{
    using TT = typename wasm_remove_const_ref<T>::type;
    static const char value = '*';
};

template <typename T>
struct m3_type_to_sig<T, typename std::enable_if<!std::is_reference<T>::value>::type>
{
    using TT = typename wasm_remove_const_ref<T>::type;
    static const char value = _m3_type_to_sig<TT>::value;
};

template <typename Ret, typename... Args>
struct m3_signature
{
    //不支持返回值的引用
    static_assert(!std::is_reference<Ret>::value, "");

    static const char* get()
    {
        static char value[] = {m3_type_to_sig<Ret>::value, '(', m3_type_to_sig<Args>::value..., ')', 0};
        return (const char*) value;
    }
};
//记录不同类型的指针,再wasm存的类型
template <typename T, typename = void>
struct _wasm_pointer_support_ptr_in_wasm;

template <typename T>
struct _wasm_pointer_support_ptr_in_wasm<T, typename std::enable_if<std::is_base_of<UObject, T>::value>::type>
{
    using type = UObjectBase*;
};

template <typename T>
struct _wasm_pointer_support_ptr_in_wasm<T, typename std::enable_if<!std::is_base_of<UObject, T>::value>::type>
{
    using type = void*;
};

template <typename T>
struct wasm_pointer_support_ptr_in_wasm
{
    using type = typename _wasm_pointer_support_ptr_in_wasm<
        typename std::remove_pointer<typename wasm_remove_const_ref<T>::type>::type>::type;
};

//指针
template <typename T, typename memstack_t = typename std::add_pointer_t<typename std::remove_reference_t<T>>,
    typename t_remove_pointer = typename std::remove_pointer<T>::type>
typename std::enable_if<wasm_is_support_pointer_type<T>::value, int>::type wasm_link_get_args_from_stack(
    IM3Runtime rt, IM3ImportContext _ctx, wasm_stack_type _sp, wasm_mem_type _mem, memstack_t& stack_ptr, int index)
{
    using ptr_type_in_wasm = typename wasm_pointer_support_ptr_in_wasm<T>::type;
    WASM_PTR offset = *((WASM_PTR*) (_sp + index));
    ptr_type_in_wasm* tmp = (ptr_type_in_wasm*) m3ApiOffsetToPtr(offset);
    *stack_ptr = static_cast<T>(*tmp);
    return 0;
}

//简单类型,非引用
template <typename T, typename memstack_t = typename std::add_pointer_t<typename std::remove_reference_t<T>>>
typename std::enable_if<wasm_is_simple_type<T>::value && !std::is_reference<T>::value, int>::type wasm_link_get_args_from_stack(
    IM3Runtime rt, IM3ImportContext _ctx, wasm_stack_type _sp, wasm_mem_type _mem, memstack_t& stack_ptr, int index)
{
    T tmp = *((T*) (_sp + index));
    *stack_ptr = tmp;
    return 0;
}

//简单类型引用
template <typename T, typename memstack_t = typename std::add_pointer_t<typename std::remove_reference_t<T>>>
typename std::enable_if<wasm_is_simple_type<T>::value && std::is_reference<T>::value, int>::type wasm_link_get_args_from_stack(
    IM3Runtime rt, IM3ImportContext _ctx, wasm_stack_type _sp, wasm_mem_type _mem, memstack_t& stack_ptr, int index)
{
    using T_noRef = typename std::remove_reference_t<T>;
    WASM_PTR offset = *((WASM_PTR*) (_sp + index));
    T_noRef* tmp = (T_noRef*) m3ApiOffsetToPtr(offset);
    stack_ptr = tmp;
    return 0;
}

//复杂类型
template <typename T, typename memstack_t = typename std::add_pointer_t<typename std::remove_reference_t<T>>>
typename std::enable_if<wasm_is_complex_type<T>::value, int>::type wasm_link_get_args_from_stack(
    IM3Runtime rt, IM3ImportContext _ctx, wasm_stack_type _sp, wasm_mem_type _mem, memstack_t& stack_ptr, int index)
{
    using T_noRef = typename std::remove_reference_t<T>;
    WASM_PTR offset = *((WASM_PTR*) (_sp + index));
    T_noRef* tmp = (T_noRef*) m3ApiOffsetToPtr(offset);
    stack_ptr = tmp;
    return 0;
}

template <typename Func, Func* func>
struct wasm_link_helper;

template <typename Ret, typename... Args, Ret (*func)(Args...)>
struct wasm_link_helper<Ret(Args...), func>
{
    template <typename X>
    struct Functor;

    template <int... Index>
    struct Functor<std::index_sequence<Index...>>
    {
        //返回值是指针
        //规避malloc,需要link的函数,返回值禁止是指针
        /*template<class T>
        static typename std::enable_if<wasm_is_support_pointer_type<T>::value && !std::is_same<T, void>::value, const void*>::type
        _InternalInvoke(IM3Runtime rt, IM3ImportContext _ctx, wasm_stack_type _sp, wasm_mem_type _mem)
        {
            m3ApiReturnType(WASM_PTR);
            auto stack_mem = std::make_tuple<typename std::remove_reference_t<Args>...>(typename
        std::remove_reference_t<Args>()...); auto parm = std::make_tuple<typename std::add_pointer_t<typename
        std::remove_reference_t<Args>>...>(&std::get<Index>(stack_mem)...); auto tmp =
        std::make_tuple(wasm_link_get_args_from_stack<Args>(rt, _ctx, _sp, _mem, std::get<Index>(parm), Index)...);
            //_sp += sizeof...(Args);
            using T_RemoveConst = typename wasm_remove_const_ref<T>::type;
            T_RemoveConst r = (T_RemoveConst)func(*std::get<Index>(parm)...);
            WASM_PTR ptr = TryGetWasmPointerWithObject(r, rt);
            {
                *raw_return = ptr;
                return nullptr;
            }
        }*/

        //没有返回值
        template <class T>
        static typename std::enable_if<std::is_same<T, void>::value, void>::type _InternalInvoke(
            IM3Runtime rt, IM3ImportContext _ctx, wasm_stack_type _sp, wasm_mem_type _mem)
        {
            auto stack_mem =
                std::make_tuple<typename std::remove_reference_t<Args>...>(typename std::remove_reference_t<Args>()...);
            auto parm = std::make_tuple<typename std::add_pointer_t<typename std::remove_reference_t<Args>>...>(
                &std::get<Index>(stack_mem)...);
            auto tmp = std::make_tuple(wasm_link_get_args_from_stack<Args>(rt, _ctx, _sp, _mem, std::get<Index>(parm), Index)...);
            //_sp不是引用,所以也不用加了
            //_sp += sizeof...(Args);
            func(*std::get<Index>(parm)...);
            return nullptr;
        }
        //返回值是复杂类型
        template <class T>
        static typename std::enable_if<wasm_is_complex_type<T>::value && !std::is_same<T, void>::value, const void*>::type
        _InternalInvoke(IM3Runtime rt, IM3ImportContext _ctx, wasm_stack_type _sp, wasm_mem_type _mem)
        {
            using T_RemoveConst = typename wasm_remove_const_ref<T>::type;
            m3ApiReturnType(WASM_PTR);
            T_RemoveConst* ptr = (T_RemoveConst*) m3ApiOffsetToPtr(*raw_return);

            auto stack_mem =
                std::make_tuple<typename std::remove_reference_t<Args>...>(typename std::remove_reference_t<Args>()...);
            auto parm = std::make_tuple<typename std::add_pointer_t<typename std::remove_reference_t<Args>>...>(
                &std::get<Index>(stack_mem)...);
            auto tmp = std::make_tuple(wasm_link_get_args_from_stack<Args>(rt, _ctx, _sp, _mem, std::get<Index>(parm), Index)...);
            //_sp += sizeof...(Args);

            *ptr = func(*std::get<Index>(parm)...);

            return nullptr;
        }
        //返回值是简单类型
        template <class T>
        static typename std::enable_if<wasm_is_simple_type<T>::value && !std::is_same<T, void>::value, const void*>::type
        _InternalInvoke(IM3Runtime rt, IM3ImportContext _ctx, wasm_stack_type _sp, wasm_mem_type _mem)
        {
            m3ApiReturnType(T);
            auto stack_mem =
                std::make_tuple<typename std::remove_reference_t<Args>...>(typename std::remove_reference_t<Args>()...);
            auto parm = std::make_tuple<typename std::add_pointer_t<typename std::remove_reference_t<Args>>...>(
                &std::get<Index>(stack_mem)...);
            auto tmp = std::make_tuple(wasm_link_get_args_from_stack<Args>(rt, _ctx, _sp, _mem, std::get<Index>(parm), Index)...);
            //_sp += sizeof...(Args);

            T r = func(*std::get<Index>(parm)...);
            {
                *raw_return = r;
                return nullptr;
            }
        }

        static const void* Invoke(IM3Runtime rt, IM3ImportContext _ctx, wasm_stack_type _sp, wasm_mem_type _mem)
        {
            return _InternalInvoke<Ret>(rt, _ctx, _sp, _mem);
        }
    };
};

template <typename Func, Func* func>
struct wasm_link_wrapper;

template <typename Ret, typename... Args, Ret (*func)(Args...)>
struct wasm_link_wrapper<Ret(Args...), func>
{
    //为了规避malloc,暂时禁止返回值是指针的函数link
    /*template<typename T>
    static typename std::enable_if<wasm_is_support_pointer_type<T>::value && !std::is_same<T, void>::value, bool>::type
    InternalLink(IM3Module _module, const char* const function_name)
    {
        //返回值不能是引用
        static_assert(!std::is_reference<Ret>::value, "");
        return Export_m3_LinkRawFunctionEx(_module, "*", function_name, m3_signature<Ret, Args...>::get(),
            &wasm_link_helper<Ret(Args...), func>::template Functor<std::make_index_sequence<sizeof...(Args)>>::Invoke, nullptr);
    }*/

    template <typename T>
    static typename std::enable_if<std::is_same<T, void>::value, bool>::type InternalLink(
        IM3Module _module, const char* const function_name)
    {
        return Export_m3_LinkRawFunctionEx(_module, "*", function_name, m3_signature<void, Args...>::get(),
            &wasm_link_helper<void(Args...), func>::template Functor<std::make_index_sequence<sizeof...(Args)>>::Invoke, nullptr);
    }

    template <typename T>
    static typename std::enable_if<wasm_is_simple_type<T>::value && !std::is_same<T, void>::value, bool>::type InternalLink(
        IM3Module _module, const char* const function_name)
    {
        //返回值不能是引用
        static_assert(!std::is_reference<Ret>::value, "");
        return Export_m3_LinkRawFunctionEx(_module, "*", function_name, m3_signature<Ret, Args...>::get(),
            &wasm_link_helper<Ret(Args...), func>::template Functor<std::make_index_sequence<sizeof...(Args)>>::Invoke, nullptr);
    }

    template <typename T>
    static typename std::enable_if<wasm_is_complex_type<T>::value && !std::is_same<T, void>::value, bool>::type InternalLink(
        IM3Module _module, const char* const function_name)
    {
        //返回值不能是引用
        static_assert(!std::is_reference<Ret>::value, "");
        return Export_m3_LinkRawFunctionEx(_module, "*", function_name, m3_signature<void, Ret&, Args...>::get(),
            &wasm_link_helper<Ret(Args...), func>::template Functor<std::make_index_sequence<sizeof...(Args)>>::Invoke, nullptr);
    }

    static bool link(IM3Module _module, const char* const function_name)
    {
        return InternalLink<Ret>(_module, function_name);
    }
};