#if RUNTIME_MONO

#include <cassert>
#include <cstring>
#include "mono-api.h"
#include "../libmono/icalls/mscorlib/System.Diagnostics/StackFrame.h"
#include "../libmono/icalls/mscorlib/System.Diagnostics/StackTrace.h"
#include "../libmono/icalls/mscorlib/System.Runtime.InteropServices/Marshal.h"
#include "../libmono/vm/StackTrace.h"
#include "../libmono/vm/MetadataCache.h"
#include "il2cpp-callbacks.h"
#include "il2cpp-mono-support.h"
#include "il2cpp-class-internals.h"
#include "il2cpp-object-internals.h"
#include <iterator>
#include "os/Image.h"
#include "os/Thread.h"
#include "os/c-api/Allocator.h"
#include "utils/PathUtils.h"
#include "utils/StringUtils.h"
#include "utils/Environment.h"
#include "utils/utf8-cpp/source/utf8.h"
#include "vm-utils/Debugger.h"
#include "vm-utils/NativeSymbol.h"

static void* il2cpp_get_vtable_trampoline(MonoVTable *vtable, int slot_index)
{
    return 0;
}

static void* il2cpp_get_imt_trampoline(MonoVTable *vtable, int imt_slot_index)
{
    return 0;
}

static void mono_thread_start_cb(intptr_t tid, void* stack_start, void* func)
{
    mono::vm::StackTrace::InitializeStackTracesForCurrentThread();
}

static void mono_thread_attach_cb(intptr_t tid, void* stack_start)
{
    mono::vm::StackTrace::InitializeStackTracesForCurrentThread();
}

static void mono_thread_cleanup_cb(MonoNativeThreadId tid)
{
    //assert(tid == il2cpp::os::Thread::CurrentThreadId());
    //mono::vm::StackTrace::CleanupStackTracesForCurrentThread();
}

static void il2cpp_throw_exception(MonoException* ex)
{
    if (mono_unity_exception_get_trace_ips(ex) == NULL)
    {
        // Only write the stack trace if there is not one already in the exception.
        // When we exit managed try/finally and try/catch blocks with an exception, this method is
        // called with the original exception which already has the proper stack trace.
        // Getting the stack trace again here will lose the frames between the original throw
        // and the finally or catch block.
        const mono::vm::StackFrames& frames = *mono::vm::StackTrace::GetStackFrames();
        size_t i = frames.size() - 1;
        MonoArray* ips = MonoArrayNew(mono_unity_defaults_get_int_class(), frames.size());
        for (mono::vm::StackFrames::const_iterator iter = frames.begin(); iter != frames.end(); ++iter, --i)
        {
            mono_array_set(ips, const MonoMethod*, i, (*iter).method);
        }

        mono_unity_exception_set_trace_ips(ex, ips);
    }

    throw Il2CppExceptionWrapper(ex);
}

static void il2cpp_walk_stack_with_ctx(MonoInternalStackWalk func, MonoContext *ctx, MonoUnwindOptions options, void *user_data)
{
    mono::vm::StackTrace::WalkFrameStack(func, ctx, user_data);
}

static int32_t il2cpp_exception_walk_trace(MonoException *ex, MonoInternalExceptionFrameWalk func, void* user_data)
{
    MonoArray *ta = mono_unity_exception_get_trace_ips(ex);
    int len, i;

    if (ta == NULL)
        return 0;

    len = (int)mono_array_length(ta) >> 1;
    for (i = 0; i < len; i++)
    {
        void* ip = mono_array_get(ta, void*, i * 2 + 0);
        void* generic_info = mono_array_get(ta, void*, i * 2 + 1);
        const MonoMethod* method = il2cpp::utils::NativeSymbol::GetMethodFromNativeSymbol((Il2CppMethodPointer)ip);

        if (method == NULL)
        {
            if (func(NULL, ip, 0, 0, user_data))
                return 1;
        }
        else
        {
            if (func(const_cast<MonoMethod*>(method), ip, 0, 1, user_data))
                return 1;
        }
    }

    return len > 0;
}

static int32_t il2cpp_current_thread_has_handle_block_guard()
{
    return 0;
}

static gboolean il2cpp_install_handler_block_guard(MonoThreadUnwindState *ctx)
{
    return false;
}

static MonoObject* il2cpp_mono_fake_box(void *ptr)
{
    return ((MonoObject*)ptr) - 1;
}

MonoObject* il2cpp_mono_determine_target_object(MonoMethod *method, MonoObject *obj)
{
    if (!obj)
        return NULL;

    if (mono_class_is_valuetype(mono_unity_method_get_class(method)))
        return obj;

    MonoClass *klass = mono_unity_object_get_class(obj);
    if (mono_unity_class_is_delegate(klass) && (strcmp(mono_unity_method_get_name(method), "Invoke") != 0))
        return mono_unity_delegate_get_target((MonoDelegate*)obj);

    return obj;
}

MonoObject* il2cpp_mono_runtime_invoke(MonoMethod *method, void *obj, void **params, MonoObject **exc, MonoError *error)
{
    il2cpp_mono_method_initialize_function_pointers(method, error);
    if (!il2cpp_mono_error_ok(error))
        return NULL;

    if (exc)
        *exc = NULL;

    MonoObject *target = il2cpp_mono_determine_target_object(method, (MonoObject*)obj);

    void **newParams = params;
    std::vector<void*> newParamsVec;
    std::vector<int> byRefParams;

    if (params && mono_method_signature(method))
    {
        int numParams = mono_unity_signature_num_parameters(mono_method_signature(method));
        if (numParams > 0)
        {
            newParamsVec.resize(numParams);
            for (int i = 0; i < numParams; ++i)
            {
                MonoClass *paramSigClass = mono_unity_signature_get_class_for_param(mono_method_signature(method), i);
                if (mono_class_is_nullable(paramSigClass))
                {
                    if (mono_unity_signature_param_is_byref(mono_method_signature(method), i))
                        byRefParams.push_back(i);

                    MonoObject *paramObj = (MonoObject*)params[i];
                    void *nullable = alloca(mono_unity_class_get_instance_size(paramSigClass));
                    mono_nullable_init((uint8_t*)nullable, paramObj, paramSigClass);
                    newParamsVec[i] = nullable;
                }
                else
                {
                    newParamsVec[i] = params[i];
                }
            }

            newParams = &newParamsVec[0];
        }
    }

    if (mono_class_is_nullable(mono_unity_method_get_class(method)))
        target = mono_value_box(g_MonoDomain, mono_unity_class_get_castclass(mono_unity_method_get_class(method)), target);
    else if (target != NULL && mono_class_is_valuetype(mono_unity_method_get_class(method)))
        target = il2cpp_mono_fake_box(target);

    try
    {
        MonoClass *klass = mono_method_get_class(method);

        if (strcmp(mono_unity_method_get_name(method), ".ctor") == 0 || (mono_unity_method_is_static(method) && mono_unity_class_has_cctor(klass)))
            mono_runtime_class_init_full(il2cpp_mono_class_vtable(g_MonoDomain, klass), error);

        void *retVal = ((InvokerMethod)mono_unity_method_get_invoke_pointer(method))((Il2CppMethodPointer)mono_unity_method_get_method_pointer(method), method, target, newParams);

        std::vector<int>::const_iterator end = byRefParams.end();
        for (std::vector<int>::const_iterator it = byRefParams.begin(); it != end; ++it)
        {
            MonoClass *paramSigClass = mono_unity_signature_get_class_for_param(mono_method_signature(method), *it);
            params[*it] = mono_value_box(g_MonoDomain, paramSigClass, newParamsVec[*it]);
        }

        return mono_unity_method_convert_return_type_if_needed(method, retVal);
    }
    catch (Il2CppExceptionWrapper& ex)
    {
        if (exc)
            *exc = (MonoObject*)ex.ex;
        else
            mono_set_pending_exception((MonoException*)ex.ex);

        return NULL;
    }
}

MonoObject* il2cpp_mono_finalize_runtime_invoke(MonoObject *this_obj, void **params, MonoObject **exc, void* compiled_method)
{
    MonoMethod* finalizer = mono_class_get_finalizer(mono_object_get_class(this_obj));
    if (finalizer == NULL)
    {
        assert(0 && "Why did we get a NULL finalizer? Something may not be correct.");
        return NULL;
    }

    MonoError unused;
    return il2cpp_mono_runtime_invoke(finalizer, this_obj, params, exc, &unused);
}

void il2cpp_mono_set_cast_details(MonoClass *from, MonoClass *to)
{
}

MonoObject* il2cpp_mono_capture_context_runtime_invoke(MonoObject *this_obj, void **params, MonoObject **exc, void* compiled_method)
{
    return NULL;
}

void il2cpp_mono_dummy_callback()
{
}

void* il2cpp_mono_delegate_trampoline(MonoDomain *domain, MonoClass *klass)
{
    int vtableSize = mono_class_get_vtable_size(klass);
    MonoMethod *method = NULL;

    for (int i = 0; i < vtableSize; ++i)
    {
        MonoMethod *vtableMethod = mono_class_get_vtable_entry(klass, i);
        const char *vtableMethodName = mono_unity_method_get_name(vtableMethod);
        const char *substr = strstr(vtableMethodName, "Invoke");
        if (substr == vtableMethodName) //if the pointers are equal, vtableMethodName starts with "Invoke"
        {
            method = vtableMethod;
            break;
        }
    }

    if (!method)
        return NULL;

    MonoError unused;
    il2cpp_mono_method_initialize_function_pointers(method, &unused);
    return mono_unity_method_get_method_pointer(method);
}

void* il2cpp_mono_create_jump_trampoline(MonoDomain *domain, MonoMethod *method, gboolean add_sync_wrapper, MonoError *error)
{
    il2cpp_mono_method_initialize_function_pointers(method, error);
    return mono_unity_method_get_method_pointer(method);
}

void* il2cpp_mono_create_ftnptr(MonoDomain *domain, void* addr)
{
    return addr;
}

char* il2cpp_mono_get_runtime_build_info()
{
    return mono_unity_get_runtime_build_info(__DATE__, __TIME__);
}

#if IL2CPP_MONO_DEBUGGER
void il2cpp_debugger_save_thread_context(Il2CppThreadUnwindState* context, int frameCountAdjust)
{
    il2cpp::utils::Debugger::SaveThreadContext(context, frameCountAdjust);
}

#endif

void il2cpp_install_callbacks()
{
    MonoRuntimeCallbacks callbacks;

    g_MonoDomain = mono_domain_get();

    memset(&callbacks, 0, sizeof(callbacks));
    callbacks.get_vtable_trampoline = il2cpp_get_vtable_trampoline;
    callbacks.get_imt_trampoline = il2cpp_get_imt_trampoline;
    callbacks.runtime_invoke = il2cpp_mono_runtime_invoke;
    callbacks.set_cast_details = il2cpp_mono_set_cast_details;
    callbacks.create_jump_trampoline = il2cpp_mono_create_jump_trampoline;
    callbacks.create_ftnptr = il2cpp_mono_create_ftnptr;
    callbacks.get_runtime_build_info = il2cpp_mono_get_runtime_build_info;
    callbacks.create_delegate_trampoline = il2cpp_mono_delegate_trampoline;
#if IL2CPP_MONO_DEBUGGER
    // These don't exist in the Mono code used by default. We might need to add them (or something similar)
    // later. I'll comment them out to get the build working for now though.
    //callbacks.il2cpp_debugger_save_thread_context = il2cpp_debugger_save_thread_context;
    //callbacks.get_global_breakpoint_state_pointer =il2cpp::utils::Debugger::GetGlobalBreakpointPointer;
#endif

    mono_install_callbacks(&callbacks);

    MonoRuntimeExceptionHandlingCallbacks cbs;
    memset(&cbs, 0, sizeof(cbs));
    cbs.mono_raise_exception = il2cpp_throw_exception;
    cbs.mono_walk_stack_with_ctx = il2cpp_walk_stack_with_ctx;
    cbs.mono_install_handler_block_guard = il2cpp_install_handler_block_guard;
    cbs.mono_exception_walk_trace = il2cpp_exception_walk_trace;
    cbs.mono_current_thread_has_handle_block_guard = il2cpp_current_thread_has_handle_block_guard;
    mono_install_eh_callbacks(&cbs);

    mono_unity_domain_install_finalize_runtime_invoke(g_MonoDomain, il2cpp_mono_finalize_runtime_invoke);
    mono_unity_domain_install_capture_context_runtime_invoke(g_MonoDomain, il2cpp_mono_capture_context_runtime_invoke);
    mono_unity_domain_install_capture_context_method(g_MonoDomain, (void*)il2cpp_mono_dummy_callback);
    //mono_install_delegate_trampoline(il2cpp_mono_delegate_trampoline);

    MonoThreadInfoRuntimeCallbacks ticallbacks;
    memset(&ticallbacks, 0, sizeof(ticallbacks));
    ticallbacks.thread_state_init_from_handle = mono_unity_thread_state_init_from_handle;

    mono_thread_info_runtime_init(&ticallbacks);
}

void il2cpp_mono_runtime_init()
{
    register_allocator(mono_unity_alloc);
    mono_runtime_init(g_MonoDomain, mono_thread_start_cb, mono_thread_attach_cb);
    mono_threads_install_cleanup(mono_thread_cleanup_cb);
    mono_thread_attach(g_MonoDomain);
    mono_class_set_allow_gc_aware_layout(false);

    mono_add_internal_call("System.Diagnostics.StackFrame::get_frame_info", (void*)mono::icalls::mscorlib::System::Diagnostics::StackFrame::get_frame_info);
    mono_add_internal_call("System.Diagnostics.StackTrace::get_trace", (void*)mono::icalls::mscorlib::System::Diagnostics::StackTrace::get_trace);
    mono_add_internal_call("System.Runtime.InteropServices.Marshal::GetFunctionPointerForDelegateInternal", (void*)mono::icalls::mscorlib::System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegateInternal);
    mono_add_internal_call("System.Runtime.InteropServices.Marshal::GetDelegateForFunctionPointerInternal", (void*)mono::icalls::mscorlib::System::Runtime::InteropServices::Marshal::GetDelegateForFunctionPointerInternal);

    RegisterAllManagedMethods();
    initialize_interop_data_map();

    il2cpp::os::Image::Initialize();

    mono_profiler_started();
}

static void MonoSetConfigStr(const std::string& executablePath)
{
    std::string appBase = il2cpp::utils::PathUtils::DirectoryName(executablePath);
    std::string configFileName = il2cpp::utils::PathUtils::Basename(executablePath);
    configFileName.append(".config");
    mono_domain_set_config(g_MonoDomain, appBase.c_str(), configFileName.c_str());
}

void il2cpp_mono_set_config_utf16(const Il2CppChar* executablePath)
{
    IL2CPP_ASSERT(executablePath);
    std::string exePathUtf8 = il2cpp::utils::StringUtils::Utf16ToUtf8(executablePath, -1);
    MonoSetConfigStr(exePathUtf8);
}

void il2cpp_mono_set_config(const char* executablePath)
{
    IL2CPP_ASSERT(executablePath);
    std::string executablePathStr(executablePath);
    MonoSetConfigStr(executablePathStr);
}

void il2cpp_mono_set_commandline_arguments_utf16(int argc, const Il2CppChar* const* argv)
{
    std::vector<std::string> args(argc);
    for (int i = 0; i < argc; ++i)
        args[i] = il2cpp::utils::StringUtils::Utf16ToUtf8(argv[i], -1);

    std::vector<const char*> cargs(argc);
    for (int i = 0; i < argc; ++i)
        cargs[i] = args[i].c_str();

    mono_runtime_set_main_args(argc, const_cast<char**>(&cargs[0]));

    for (int i = 0; i < argc; ++i)
    {
        /* TODO: uncomment after mono debugger changes merged
        if (strncmp(args[i].c_str(), "--debugger-agent=", 17) == 0)
        {
            mono_debugger_set_il2cpp_breakpoints(g_Il2CppSequencePointCount, (Il2CppSequencePoint**)g_Il2CppSequencePoints);
            mono_debugger_agent_parse_options((char*)(args[i].c_str() + 17));
            //opt->mdb_optimizations = TRUE;
            //enable_debugging = TRUE;
           il2cpp::utils::Debugger::RegisterCallbacks(breakpoint_callback);
        }
        */
    }
    il2cpp::utils::Environment::SetMainArgs(argv, argc);
}

void il2cpp_mono_set_commandline_arguments(int argc, const char* const* argv)
{
    mono_runtime_set_main_args(argc, const_cast<char**>(argv));
    il2cpp::utils::Environment::SetMainArgs(argv, argc);
}

void il2cpp_mono_initialize_metadata()
{
    mono::vm::MetadataCache::Initialize();
}

#endif