#include <config.h>


#include <mono/utils/mono-publib.h>

/* allow Unity to use deprecated functions for now */
#ifdef MONO_RT_EXTERNAL_ONLY
#undef MONO_RT_EXTERNAL_ONLY
#define MONO_RT_EXTERNAL_ONLY
#endif
#include <mono/metadata/unity-utils.h>
#include <stdio.h>
#include <stdlib.h>
#ifdef WIN32
#include <fcntl.h>
#endif
#include <mono/metadata/exception.h>
#include <mono/metadata/object.h>
#include <mono/metadata/metadata.h>
#include <mono/metadata/tabledefs.h>
#include <mono/metadata/class-internals.h>
#include <mono/metadata/object-internals.h>
#include <mono/metadata/marshal.h>
#include <mono/metadata/metadata-internals.h>
#include <mono/metadata/profiler-private.h>
#include <mono/metadata/profiler.h>
#include <mono/metadata/reflection-internals.h>
#include <mono/metadata/threads.h>
#include <mono/metadata/threadpool.h>
#include <mono/metadata/tokentype.h>
#include <mono/utils/mono-string.h>

#if HAVE_BDWGC_GC
#include <mono/utils/gc_wrapper.h>
#endif

#include <glib.h>

#ifdef WIN32
#define UTF8_2_WIDE(src,dst) MultiByteToWideChar( CP_UTF8, 0, src, -1, dst, MAX_PATH )
#endif

#undef exit

void unity_mono_exit( int code )
{
	//fprintf( stderr, "mono: exit called, code %d\n", code );
	exit( code );
}


GString* gEmbeddingHostName = 0;


MONO_API void mono_unity_set_embeddinghostname(const char* name)
{
	gEmbeddingHostName = g_string_new(name);
}



MonoString* mono_unity_get_embeddinghostname()
{
	if (gEmbeddingHostName == 0)
		mono_unity_set_embeddinghostname("mono");
	return mono_string_new_wrapper(gEmbeddingHostName->str);
}

static gboolean socket_security_enabled = FALSE;

gboolean
mono_unity_socket_security_enabled_get ()
{
	return socket_security_enabled;
}

void
mono_unity_socket_security_enabled_set (gboolean enabled)
{
	socket_security_enabled = enabled;
}

void mono_unity_set_vprintf_func (vprintf_func func)
{
	set_vprintf_func (func);
}

MONO_API gboolean
mono_unity_class_is_interface (MonoClass* klass)
{
	return MONO_CLASS_IS_INTERFACE(klass);
}

MONO_API gboolean
mono_unity_class_is_abstract (MonoClass* klass)
{
	return (mono_class_get_flags (klass) & TYPE_ATTRIBUTE_ABSTRACT);
}

// classes_ref is a preallocated array of *length_ref MonoClass*
// returned classes are stored in classes_ref, number of stored classes is stored in length_ref
// return value is number of classes found (which may be greater than number of classes stored)
unsigned mono_unity_get_all_classes_with_name_case (MonoImage *image, const char *name, MonoClass **classes_ref, unsigned *length_ref)
{
	MonoClass *klass;
	MonoTableInfo *tdef = &image->tables [MONO_TABLE_TYPEDEF];
	int i, count;
	guint32 attrs, visibility;
	unsigned length = 0;

	/* (yoinked from icall.c) we start the count from 1 because we skip the special type <Module> */
	for (i = 1; i < tdef->rows; ++i)
	{
		klass = mono_class_get (image, (i + 1) | MONO_TOKEN_TYPE_DEF);
		if (klass && klass->name && 0 == mono_utf8_strcasecmp (klass->name, name))
		{
			if (length < *length_ref)
				classes_ref[length] = klass;
			++length;
		}
	}

	if (length < *length_ref)
		*length_ref = length;
	return length;
}

gboolean
unity_mono_method_is_generic (MonoMethod* method)
{
	return method->is_generic;
}

MONO_API MonoMethod*
unity_mono_reflection_method_get_method(MonoReflectionMethod* mrf)
{
	if(!mrf)
		return NULL;

	return mrf->method;
}

MONO_API void
mono_unity_g_free(void *ptr)
{
	g_free (ptr);
}


MONO_API MonoClass*
mono_custom_attrs_get_attrs (MonoCustomAttrInfo *ainfo, gpointer *iter)
{
	int index = -1;
	if (!iter)
		return NULL;
	if (!*iter)
	{
		*iter = 1;
		return ainfo->attrs[0].ctor->klass;
	}

	index = GPOINTER_TO_INT (*iter);
	if (index >= ainfo->num_attrs)
		return NULL;
	*iter = GINT_TO_POINTER (index + 1);
	return ainfo->attrs[index].ctor->klass;
}

MONO_API gboolean
mono_class_is_inflated (MonoClass *klass)
{
	g_assert(klass);
	return (klass->class_kind == MONO_CLASS_GINST);
}

MONO_API void
mono_thread_pool_cleanup (void)
{
	// TODO_UNITY : I am not sure we need to call this anymore
	mono_threadpool_cleanup ();
}

MONO_API void*
mono_class_get_userdata (MonoClass* klass)
{
	return klass->unity_user_data;
}

MONO_API void
mono_class_set_userdata(MonoClass* klass, void* userdata)
{
	klass->unity_user_data = userdata;
}

MONO_API int
mono_class_get_userdata_offset()
{
	return offsetof(struct _MonoClass, unity_user_data);
}


static UnityFindPluginCallback unity_find_plugin_callback;

MONO_API void
mono_set_find_plugin_callback (UnityFindPluginCallback find)
{
	unity_find_plugin_callback = find;
}

MONO_API UnityFindPluginCallback
mono_get_find_plugin_callback ()
{
	return unity_find_plugin_callback;
}

//object

void mono_unity_object_init(void* obj, MonoClass* klass)
{
	if (klass->valuetype)
		memset(obj, 0, klass->instance_size - sizeof(MonoObject));
	else
		*(MonoObject**)obj = NULL;
}

MonoObject* mono_unity_object_isinst_sealed(MonoObject* obj, MonoClass* targetType)
{
	return obj->vtable->klass == targetType ? obj : NULL;
}

void mono_unity_object_unbox_nullable(MonoObject* obj, MonoClass* nullableArgumentClass, void* storage)
{
	uint32_t valueSize = nullableArgumentClass->instance_size - sizeof(MonoObject);

	if (obj == NULL)
	{
		*((mono_byte*)(storage)+valueSize) = 0;
	}
	else if (obj->vtable->klass != nullableArgumentClass)
	{
		mono_raise_exception_deprecated (mono_get_exception_invalid_cast());
	}
	else
	{
		memcpy(storage, mono_object_unbox(obj), valueSize);
		*((mono_byte*)(storage)+valueSize) = 1;
	}
}

MonoClass* mono_unity_object_get_class(MonoObject *obj)
{
	return obj->vtable->klass;
}

MonoObject* mono_unity_object_compare_exchange(MonoObject **location, MonoObject *value, MonoObject *comparand)
{
	return ves_icall_System_Threading_Interlocked_CompareExchange_T(location, value, comparand);
}

MonoObject* mono_unity_object_exchange(MonoObject **location, MonoObject *value)
{
	return ves_icall_System_Threading_Interlocked_Exchange_T(location, value);
}

gboolean mono_unity_object_check_box_cast(MonoObject *obj, MonoClass *klass)
{
	return (obj->vtable->klass->element_class == klass->element_class);
}

//class

const char* mono_unity_class_get_image_name(MonoClass* klass)
{
	return klass->image->assembly_name;
}

MonoClass* mono_unity_class_get_generic_definition(MonoClass* klass)
{
	MonoGenericClass* generic_class = mono_class_try_get_generic_class (klass);
	if (generic_class)
		return generic_class->container_class;

	return NULL;
}

MonoClass* mono_unity_class_inflate_generic_class(MonoClass *gklass, MonoGenericContext *context)
{
	MonoError error;
	return mono_class_inflate_generic_class_checked(gklass, context, &error);
}

gboolean mono_unity_class_has_parent_unsafe(MonoClass *klass, MonoClass *parent)
{
	return mono_class_has_parent_fast(klass, parent);
}

MonoAssembly* mono_unity_class_get_assembly(MonoClass *klass)
{
	return klass->image->assembly;
}

gboolean mono_unity_class_is_array(MonoClass *klass)
{
	return klass->rank > 0;
}

MonoClass* mono_unity_class_get_element_class(MonoClass *klass)
{
	return klass->element_class;
}

gboolean mono_unity_class_is_delegate(MonoClass *klass)
{
	return klass->delegate;
}

int mono_unity_class_get_instance_size(MonoClass *klass)
{
	return klass->instance_size;
}

MonoClass* mono_unity_class_get_castclass(MonoClass *klass)
{
	return klass->cast_class;
}

guint32 mono_unity_class_get_native_size(MonoClass* klass)
{
	MonoMarshalType* info = mono_marshal_load_type_info(klass);
	return info->native_size;
}

MonoBoolean mono_unity_class_is_string(MonoClass* klass)
{
	if (mono_class_get_type(klass)->type == MONO_TYPE_STRING)
		return TRUE;
	return FALSE;
}

MonoBoolean mono_unity_class_is_class_type(MonoClass* klass)
{
	if (mono_class_get_type(klass)->type == MONO_TYPE_CLASS)
		return TRUE;
	return FALSE;
}

MONO_API gboolean
mono_class_is_generic(MonoClass *klass)
{
	g_assert(klass);
	return (klass->class_kind == MONO_CLASS_GTD);
}

MONO_API gboolean
mono_class_is_blittable(MonoClass *klass)
{
	g_assert(klass);
	return klass->blittable;
}

gboolean mono_unity_class_has_cctor(MonoClass *klass)
{
    return klass->has_cctor ? TRUE : FALSE;
}

//method

MonoMethod* mono_unity_method_get_generic_definition(MonoMethod* method)
{
	if (method->is_inflated)
		return ((MonoMethodInflated*)method)->declaring;

	return NULL;
}

MonoReflectionMethod* mono_unity_method_get_object(MonoMethod *method)
{
	MonoError unused;
	return mono_method_get_object_checked(mono_domain_get(), method, NULL, &unused);
}

MonoMethod* mono_unity_method_alloc0(MonoClass* klass)
{
	return mono_image_alloc0(klass->image, sizeof(MonoMethod));
}

MonoMethod* mono_unity_method_delegate_invoke_wrapper(MonoClass* klass)
{
	MonoMethod* method = (MonoMethod*)mono_image_alloc0(klass->image, sizeof(MonoMethod));
	MonoMethod *invoke = mono_get_delegate_invoke (klass);
	method->signature = mono_metadata_signature_dup_full (klass->image, mono_method_signature (invoke));
	return method;
}

gboolean mono_unity_method_is_static(MonoMethod *method)
{
	return method->flags & METHOD_ATTRIBUTE_STATIC;
}

MonoClass* mono_unity_method_get_class(const MonoMethod *method)
{
	return method->klass;
}

#ifdef IL2CPP_ON_MONO

void* mono_unity_method_get_method_pointer(MonoMethod* method)
{
	return method->method_pointer;
}

void mono_unity_method_set_method_pointer(MonoMethod* method, void *p)
{
	method->method_pointer = p;
}

void* mono_unity_method_get_invoke_pointer(MonoMethod* method)
{
	return method->invoke_pointer;
}

void mono_unity_method_set_invoke_pointer(MonoMethod* method, void *p)
{
	method->invoke_pointer = p;
}

#endif

const char* mono_unity_method_get_name(const MonoMethod *method)
{
	return method->name;
}


//must match the hash in il2cpp code generation
static guint32 hash_string_djb2(guchar *str)
{
	guint32 hash = 5381;
	int c;

	while (c = *str++)
		hash = ((hash << 5) + hash) + c; /* hash * 33 + c */

	return hash;
}

static guint32 get_array_structure_hash(MonoArrayType *atype)
{
	char buffer[100];
	char *ptr = buffer;

	*ptr++ = '[';

	char numbuffer[10];

	for (int i = 0; i < atype->rank; ++i)
	{
		if (atype->numlobounds > 0 && atype->lobounds[i] != 0)
		{
			snprintf(numbuffer, 10, "%d", atype->lobounds[i]);
			char *ptrnum = numbuffer;
			while (*ptrnum)
				*ptr++ = *ptrnum++;

			*ptr++ = ':';
		}

		if (atype->numsizes > 0 && atype->sizes[i] != 0)
		{
			snprintf(numbuffer, 10, "%d", atype->sizes[i]);
			char *ptrnum = numbuffer;
			while (*ptrnum)
				*ptr++ = *ptrnum++;
		}

		if (i < atype->rank - 1)
			*ptr++ = ',';
	}

	*ptr++ = ']';
	*ptr++ = 0;

	return hash_string_djb2(buffer);
}

/* Begin: Hash computation helper functions */

static void get_type_hashes(MonoType *type, GList *hashes, gboolean inflate);
static void get_type_hashes_generic_inst(MonoGenericInst *inst, GList *hashes, gboolean inflate);


static void get_type_hashes_generic_inst(MonoGenericInst *inst, GList *hashes, gboolean inflate)
{
	for (int i = 0; i < inst->type_argc; ++i)
	{
		MonoType *type = inst->type_argv[i];
		get_type_hashes(type, hashes, inflate);
	}
}

static void get_type_hashes(MonoType *type, GList *hashes, gboolean inflate)
{
	if (type->type != MONO_TYPE_GENERICINST)
	{
		MonoClass *klass = NULL;

		switch (type->type)
		{
		case MONO_TYPE_ARRAY:
		{
			MonoArrayType *atype = type->data.array;
			g_list_append(hashes, MONO_TOKEN_TYPE_SPEC);
			g_list_append(hashes, get_array_structure_hash(atype));
			get_type_hashes(&(atype->eklass->this_arg), hashes, inflate);
			break;
		}
		case MONO_TYPE_CLASS:
		case MONO_TYPE_VALUETYPE:
			klass = type->data.klass;
			break;
		case MONO_TYPE_BOOLEAN:
			klass = mono_defaults.boolean_class;
			break;
		case MONO_TYPE_CHAR:
			klass = mono_defaults.char_class;
			break;
		case MONO_TYPE_I:
			klass = mono_defaults.int_class;
			break;
		case MONO_TYPE_U:
			klass = mono_defaults.uint_class;
			break;
		case MONO_TYPE_I1:
			klass = mono_defaults.sbyte_class;
			break;
		case MONO_TYPE_U1:
			klass = mono_defaults.byte_class;
			break;
		case MONO_TYPE_I2:
			klass = mono_defaults.int16_class;
			break;
		case MONO_TYPE_U2:
			klass = mono_defaults.uint16_class;
			break;
		case MONO_TYPE_I4:
			klass = mono_defaults.int32_class;
			break;
		case MONO_TYPE_U4:
			klass = mono_defaults.uint32_class;
			break;
		case MONO_TYPE_I8:
			klass = mono_defaults.int64_class;
			break;
		case MONO_TYPE_U8:
			klass = mono_defaults.uint64_class;
			break;
		case MONO_TYPE_R4:
			klass = mono_defaults.single_class;
			break;
		case MONO_TYPE_R8:
			klass = mono_defaults.double_class;
			break;
		case MONO_TYPE_STRING:
			klass = mono_defaults.string_class;
			break;
		case MONO_TYPE_OBJECT:
			klass = mono_defaults.object_class;
			break;
		}

		if (klass)
		{
			g_list_append(hashes, klass->type_token);
			g_list_append(hashes, hash_string_djb2(klass->image->module_name));
		}

		return;
	}
	else
	{
		g_list_append(hashes, type->data.generic_class->container_class->type_token);
		g_list_append(hashes, hash_string_djb2(type->data.generic_class->container_class->image->module_name));

        if (inflate)
		    get_type_hashes_generic_inst(type->data.generic_class->context.class_inst, hashes, inflate);
	}

}

static GList* get_type_hashes_method(MonoMethod *method, gboolean inflate)
{
	GList *hashes = monoeg_g_list_alloc();

	hashes->data = method->token;
	g_list_append(hashes, hash_string_djb2(method->klass->image->module_name));

	if (inflate && method->klass->class_kind == MONO_CLASS_GINST)
	{
		g_list_append(hashes, method->klass->type_token);
		get_type_hashes_generic_inst(mono_class_get_generic_class (method->klass)->context.class_inst, hashes, inflate);
	}

	if (inflate && method->is_inflated)
	{
		MonoGenericContext* methodGenericContext = mono_method_get_context(method);
		if (methodGenericContext->method_inst != NULL)
			get_type_hashes_generic_inst(methodGenericContext->method_inst, hashes, inflate);
	}

	return hashes;
}

//hash combination function must match the one used in IL2CPP codegen
static guint64 combine_hashes(guint64 hash1, guint64 hash2)
{
	const guint64 seed = 486187739;
	return hash1 * seed + hash2;
}

static void combine_all_hashes(gpointer data, gpointer user_data)
{
	guint64 *hash = (guint64*)user_data;
	if (*hash == 0)
		*hash = (guint64)data;
	else
		*hash = combine_hashes(*hash, (guint64)(uintptr_t)data);
}

/* End: Hash computation helper functions */

guint64 mono_unity_method_get_hash(MonoMethod *method, gboolean inflate)
{
	GList *hashes = get_type_hashes_method(method, inflate);

	guint64 hash = 0;

	g_list_first(hashes);
	g_list_foreach(hashes, combine_all_hashes, &hash);
	g_list_free(hashes);

	return hash;
}

guint64 mono_unity_type_get_hash(MonoType *type, gboolean inflate)
{
    GList *hashes = monoeg_g_list_alloc();

    get_type_hashes(type, hashes, inflate);
    
    guint64 hash = 0;

    g_list_first(hashes);
    g_list_foreach(hashes, combine_all_hashes, &hash);
    g_list_free(hashes);

    return hash;
}


MonoMethod* mono_unity_method_get_aot_array_helper_from_wrapper(MonoMethod *method)
{
	MonoMethod *m;
	const char *prefix;
	MonoGenericContext ctx;
	MonoType *args[16];
	char *mname, *iname, *s, *s2, *helper_name = NULL;

	prefix = "System.Collections.Generic";
	s = g_strdup_printf("%s", method->name + strlen(prefix) + 1);
	s2 = strstr(s, "`1.");
	g_assert(s2);
	s2[0] = '\0';
	iname = s;
	mname = s2 + 3;

	//printf ("X: %s %s\n", iname, mname);

	if (!strcmp(iname, "IList"))
		helper_name = g_strdup_printf("InternalArray__%s", mname);
	else
		helper_name = g_strdup_printf("InternalArray__%s_%s", iname, mname);
	m = mono_class_get_method_from_name(mono_defaults.array_class, helper_name, mono_method_signature(method)->param_count);
	g_assert(m);
	g_free(helper_name);
	g_free(s);

	if (m->is_generic) {
		MonoError error;
		memset(&ctx, 0, sizeof(ctx));
		args[0] = &method->klass->element_class->byval_arg;
		ctx.method_inst = mono_metadata_get_generic_inst(1, args);
		m = mono_class_inflate_generic_method_checked(m, &ctx, &error);
		g_assert(mono_error_ok(&error)); /* FIXME don't swallow the error */
	}

	return m;
}

MonoObject* mono_unity_method_convert_return_type_if_needed(MonoMethod *method, void *value)
{
	if (method->signature && method->signature->ret->type == MONO_TYPE_PTR)
	{
		MonoError unused;
		return mono_value_box_checked(mono_domain_get(), mono_defaults.int_class, &value, &unused);
	}

	return (MonoObject*)value;
}

MONO_API gboolean
unity_mono_method_is_inflated(MonoMethod* method)
{
	return method->is_inflated;
}

guint32 mono_unity_method_get_token(MonoMethod *method)
{
	return method->token;
}

//domain


void mono_unity_domain_install_finalize_runtime_invoke(MonoDomain* domain, RuntimeInvokeFunction callback)
{
	domain->finalize_runtime_invoke = callback;
}

void mono_unity_domain_install_capture_context_runtime_invoke(MonoDomain* domain, RuntimeInvokeFunction callback)
{
	domain->capture_context_runtime_invoke = callback;
}

void mono_unity_domain_install_capture_context_method(MonoDomain* domain, gpointer callback)
{
	domain->capture_context_method = callback;
}


void mono_unity_domain_unload (MonoDomain* domain, MonoUnityExceptionFunc callback)
{
	MonoObject *exc = NULL;
	mono_domain_try_unload (domain, &exc, callback);
}

//array

int mono_unity_array_get_element_size(MonoArray *arr)
{
	return arr->obj.vtable->klass->sizes.element_size;
}

MonoClass* mono_unity_array_get_class(MonoArray *arr)
{
	return arr->obj.vtable->klass;
}

mono_array_size_t mono_unity_array_get_max_length(MonoArray *arr)
{
	return arr->max_length;
}

//type

gboolean mono_unity_type_is_generic_instance(MonoType *type)
{
	return type->type == MONO_TYPE_GENERICINST;
}

MonoGenericClass* mono_unity_type_get_generic_class(MonoType *type)
{
	if (type->type != MONO_TYPE_GENERICINST)
		return NULL;

	return type->data.generic_class;
}

gboolean mono_unity_type_is_enum_type(MonoType *type)
{
	if (type->type == MONO_TYPE_VALUETYPE && type->data.klass->enumtype)
		return TRUE;
	if (type->type == MONO_TYPE_GENERICINST && type->data.generic_class->container_class->enumtype)
		return TRUE;
	return FALSE;
}

gboolean mono_unity_type_is_boolean(MonoType *type)
{
	return type->type == MONO_TYPE_BOOLEAN;
}

MonoClass* mono_unity_type_get_element_class(MonoType *type)
{
	return type->data.klass->element_class;
}

//generic class

MonoGenericContext mono_unity_generic_class_get_context(MonoGenericClass *klass)
{
	return klass->context;
}

MonoClass* mono_unity_generic_class_get_container_class(MonoGenericClass *klass)
{
	return klass->container_class;
}

//method signature

MonoClass* mono_unity_signature_get_class_for_param(MonoMethodSignature *sig, int index)
{
	MonoType *type = sig->params[index];
	return mono_class_from_mono_type(type);
}

int mono_unity_signature_num_parameters(MonoMethodSignature *sig)
{
	return sig->param_count;
}

gboolean mono_unity_signature_param_is_byref(MonoMethodSignature *sig, int index)
{
	return sig->params[index]->byref;
}

//generic inst

guint mono_unity_generic_inst_get_type_argc(MonoGenericInst *inst)
{
	return inst->type_argc;
}

MonoType* mono_unity_generic_inst_get_type_argument(MonoGenericInst *inst, int index)
{
	return inst->type_argv[index];
}

//exception

MonoString* mono_unity_exception_get_message(MonoException *exc)
{
	return exc->message;
}

MonoString* mono_unity_exception_get_stack_trace(MonoException *exc)
{
	return exc->stack_trace;
}

MonoObject* mono_unity_exception_get_inner_exception(MonoException *exc)
{
	return exc->inner_ex;
}

MonoArray* mono_unity_exception_get_trace_ips(MonoException *exc)
{
	return exc->trace_ips;
}

void mono_unity_exception_set_trace_ips(MonoException *exc, MonoArray *ips)
{
	g_assert(sizeof((exc)->trace_ips) == sizeof(void**));
	mono_gc_wbarrier_set_field((MonoObject*)(exc), &((exc)->trace_ips), (MonoObject*)ips);
}

MonoException* mono_unity_exception_get_marshal_directive(const char* msg)
{
	return mono_exception_from_name_msg(mono_get_corlib(), "System.Runtime.InteropServices", "MarshalDirectiveException", msg);
}

//defaults

MonoClass* mono_unity_defaults_get_int_class()
{
	return mono_defaults.int_class;
}

MonoClass* mono_unity_defaults_get_stack_frame_class()
{
	return mono_defaults.stack_frame_class;
}

MonoClass* mono_unity_defaults_get_int32_class()
{
	return mono_defaults.int32_class;
}

MonoClass* mono_unity_defaults_get_char_class()
{
	return mono_defaults.char_class;
}

MonoClass* mono_unity_defaults_get_delegate_class()
{
	return mono_defaults.delegate_class;
}

MonoClass* mono_unity_defaults_get_byte_class()
{
	return mono_defaults.byte_class;
}

//unitytls

static unitytls_interface_struct* gUnitytlsInterface = NULL;

MONO_API unitytls_interface_struct* 
mono_unity_get_unitytls_interface()
{
	return gUnitytlsInterface;
}

// gc
MONO_API void mono_unity_gc_enable()
{
#if HAVE_BDWGC_GC
	GC_enable();
#else
	g_assert_not_reached ();
#endif
}

MONO_API void mono_unity_gc_disable()
{
#if HAVE_BDWGC_GC
	GC_disable();
#else
	g_assert_not_reached ();
#endif
}

MONO_API int mono_unity_gc_is_disabled()
{
#if HAVE_BDWGC_GC
	return GC_is_disabled ();
#else
	g_assert_not_reached ();
	return 0;
#endif	
}

MONO_API void 
mono_unity_install_unitytls_interface(unitytls_interface_struct* callbacks)
{
	gUnitytlsInterface = callbacks;
}

//misc

MonoAssembly* mono_unity_assembly_get_mscorlib()
{
	return mono_defaults.corlib->assembly;
}

MonoImage* mono_unity_image_get_mscorlib()
{
	return mono_defaults.corlib->assembly->image;
}

MonoClass* mono_unity_generic_container_get_parameter_class(MonoGenericContainer* generic_container, gint index)
{
	MonoGenericParam *param = mono_generic_container_get_param(generic_container, index);
	return mono_class_from_generic_parameter_internal(param);
}

MonoString* mono_unity_string_append_assembly_name_if_necessary(MonoString* typeName, const char* assemblyName)
{
	if (typeName != NULL)
	{
		MonoTypeNameParse info;

		// The mono_reflection_parse_type function will mangle the name, so don't use this copy later.
		MonoError unused;
		char* nameForParsing = mono_string_to_utf8_checked(typeName, &unused);
		if (mono_reflection_parse_type(nameForParsing, &info))
		{
			if (!info.assembly.name)
			{
				GString* assemblyQualifiedName = g_string_new(0);
				char* name = mono_string_to_utf8_checked(typeName, &unused);
				g_string_append_printf(assemblyQualifiedName, "%s, %s", name, assemblyName);

				typeName = mono_string_new(mono_domain_get(), assemblyQualifiedName->str);

				g_string_free(assemblyQualifiedName, FALSE);
				mono_free(name);
			}
		}

		mono_free(nameForParsing);
	}

	return typeName;
}

void mono_unity_memory_barrier()
{
	mono_memory_barrier();
}

MonoObject* mono_unity_delegate_get_target(MonoDelegate *delegate)
{
	return delegate->target;
}

gchar* mono_unity_get_runtime_build_info(const char *date, const char *time)
{
	return g_strdup_printf("Unity IL2CPP(%s %s)", date, time);
}

void* mono_unity_get_field_address(MonoObject *obj, MonoVTable *vt, MonoClassField *field)
{
	// This is a copy of mono_field_get_addr - we need to consider how to expose that on the public API.
	MONO_REQ_GC_UNSAFE_MODE;

	guint8 *src;

	if (field->type->attrs & FIELD_ATTRIBUTE_STATIC) {
		if (field->offset == -1) {
			/* Special static */
			gpointer addr;

			mono_domain_lock(vt->domain);
			addr = g_hash_table_lookup(vt->domain->special_static_fields, field);
			mono_domain_unlock(vt->domain);
			src = (guint8 *)mono_get_special_static_data(GPOINTER_TO_UINT(addr));
		}
		else {
			src = (guint8*)mono_vtable_get_static_field_data(vt) + field->offset;
		}
	}
	else {
		src = (guint8*)obj + field->offset;
	}

	return src;
}

gboolean mono_unity_thread_state_init_from_handle(MonoThreadUnwindState *tctx, MonoThreadInfo *info, void* fixme)
{
	tctx->valid = TRUE;
	tctx->unwind_data[MONO_UNWIND_DATA_DOMAIN] = mono_domain_get();
	tctx->unwind_data[MONO_UNWIND_DATA_LMF] = NULL;
	tctx->unwind_data[MONO_UNWIND_DATA_JIT_TLS] = NULL;

	return TRUE;
}

void mono_unity_stackframe_set_method(MonoStackFrame *sf, MonoMethod *method)
{
	g_assert(sizeof(sf->method) == sizeof(void**));
	MonoError unused;
	mono_gc_wbarrier_set_field((MonoObject*)(sf), &(sf->method), (MonoObject*)mono_method_get_object_checked(mono_domain_get(), method, NULL, &unused));
}

MonoType* mono_unity_reflection_type_get_type(MonoReflectionType *type)
{
	return type->type;
}

// layer to proxy differences between old and new Mono versions

MONO_API void
mono_unity_runtime_set_main_args (int argc, const char* argv[])
{
	mono_runtime_set_main_args (argc, argv);
}

MONO_API MonoString*
mono_unity_string_empty_wrapper ()
{
	return mono_string_empty (mono_domain_get ());
}

MONO_API MonoArray*
mono_unity_array_new_2d (MonoDomain *domain, MonoClass *eklass, size_t size0, size_t size1)
{
	MonoError error;
	uintptr_t sizes[] = { (uintptr_t)size0, (uintptr_t)size1 };
	MonoClass* ac = mono_array_class_get (eklass, 2);

	MonoArray* array = mono_array_new_full_checked (domain, ac, sizes, NULL, &error);
	mono_error_cleanup (&error);

	return array;
}

MONO_API MonoArray*
mono_unity_array_new_3d (MonoDomain *domain, MonoClass *eklass, size_t size0, size_t size1, size_t size2)
{
	MonoError error;
	uintptr_t sizes[] = { (uintptr_t)size0, (uintptr_t)size1, (uintptr_t)size2 };
	MonoClass* ac = mono_array_class_get (eklass, 3);

	MonoArray* array =  mono_array_new_full_checked (domain, ac, sizes, NULL, &error);
	mono_error_cleanup (&error);

	return array;
}

MONO_API void
mono_unity_domain_set_config (MonoDomain *domain, const char *base_dir, const char *config_file_name)
{
	mono_domain_set_config (domain, base_dir, config_file_name);
}

MONO_API MonoException*
mono_unity_loader_get_last_error_and_error_prepare_exception ()
{
	return NULL;
}

MONO_API void
mono_unity_install_memory_callbacks (MonoAllocatorVTable* callbacks)
{
	mono_set_allocator_vtable (callbacks);
}

static char* data_dir = NULL;
MONO_API void
mono_unity_set_data_dir(const char* dir)
{
    if (data_dir)
        g_free(data_dir);

    data_dir = g_new(char*, strlen(dir) + 1);
    strcpy(data_dir, dir);
}

MONO_API char*
mono_unity_get_data_dir()
{
    return data_dir;
}

MONO_API MonoClass*
mono_unity_class_get_generic_type_definition (MonoClass* klass)
{
	MonoGenericClass* generic_class = mono_class_try_get_generic_class (klass);
	return generic_class ? generic_class->container_class : NULL;
}

MONO_API MonoClass*
mono_unity_class_get_generic_parameter_at (MonoClass* klass, guint32 index)
{
	MonoGenericContainer* generic_container = mono_class_try_get_generic_container (klass);
	if (!generic_container || index >= generic_container->type_argc)
		return NULL;

	return mono_class_from_generic_parameter_internal (mono_generic_container_get_param (generic_container, index));
}

MONO_API guint32
mono_unity_class_get_generic_parameter_count (MonoClass* klass)
{
	MonoGenericContainer* generic_container = mono_class_try_get_generic_container (klass);

	if (!generic_container)
		return 0;

	return generic_container->type_argc;
}

MONO_API MonoClass*
mono_unity_class_get_generic_argument_at (MonoClass* klass, guint32 index)
{
	if (!mono_class_is_ginst (klass))
		return NULL;

	MonoGenericClass* generic_class = mono_class_get_generic_class (klass);

	if (index >= generic_class->context.class_inst->type_argc)
		return NULL;

	return mono_class_from_mono_type (generic_class->context.class_inst->type_argv[index]);
}

MONO_API guint32
mono_unity_class_get_generic_argument_count (MonoClass* klass)
{
	if (!mono_class_is_ginst (klass))
		return NULL;

	MonoGenericClass* generic_class = mono_class_get_generic_class (klass);

	return generic_class->context.class_inst->type_argc;
}

MONO_API MonoClass*
mono_unity_class_get(MonoImage* image, guint32 type_token)
{
	// Unity expects to try to get classes that don't exist, and
	// have a value of NULL returned. So eat the error message.
	MonoError unused;
	MonoClass* klass= mono_class_get_checked(image, type_token, &unused);
	mono_error_cleanup(&unused);
	return klass;
}

MONO_API gpointer
mono_unity_alloc(gsize size)
{
	return g_malloc(size);
}


MONO_API void
mono_unity_thread_fast_attach (MonoDomain *domain)
{
	MonoInternalThread *thread;

	g_assert (domain);
	g_assert (domain != mono_get_root_domain ());

	thread = mono_thread_internal_current ();
	g_assert (thread);

	mono_thread_push_appdomain_ref (domain);
	g_assert (mono_domain_set (domain, FALSE));

	//mono_profiler_thread_fast_attach (thread->tid);
}

MONO_API void
mono_unity_thread_fast_detach ()
{
	MonoInternalThread *thread;
	MonoDomain *current_domain;

	thread = mono_thread_internal_current ();
	g_assert (thread);

	current_domain = mono_domain_get ();

	g_assert (current_domain);
	g_assert (current_domain != mono_get_root_domain ());

	//mono_profiler_thread_fast_detach (thread->tid);

	// Migrating to the root domain and popping the domain reference allows
	// the thread to stay alive and keep running while the domain can be unloaded
	g_assert (mono_domain_set (mono_get_root_domain (), FALSE));
	mono_thread_pop_appdomain_ref ();
}

// hack, FIXME jon

/*
size_t RemapPathFunction (const char* path, char* buffer, size_t buffer_len)
	path         = original path
	buffer       = provided buffer to fill out
	buffer_len   = byte size of buffer (above)
	return value = buffer size needed, incl. terminating 0
	* may be called with buffer = null / buffer_len = 0, or a shorter-than-necessary-buffer.
	* return value is always the size _needed_; not the size written.
	* terminating zero should always be written.
	* if buffer_len is less than needed, buffer content is undefined
	* if return value is 0 no remapping is needed / available
*/
static RemapPathFunction g_RemapPathFunc = NULL;

void
mono_unity_register_path_remapper (RemapPathFunction func)
{
	g_RemapPathFunc = func;
}

/* calls remapper function if registered; allocates memory if remapping is available */
static inline size_t
call_remapper(const char* path, char** buf)
{
	size_t len;

	if (!g_RemapPathFunc)
		return 0;

	*buf = NULL;
	len = g_RemapPathFunc(path, *buf, 0);

	if (len == 0)
		return 0;

	*buf = g_new (char, len);
	g_RemapPathFunc(path, *buf, len);

	return len;
}

MonoBoolean
ves_icall_System_IO_MonoIO_RemapPath  (MonoString *path, MonoString **new_path)
{
	MonoError error;
	const gunichar2* path_remapped;

	if (!g_RemapPathFunc)
		return 0;

	path_remapped = mono_unity_remap_path_utf16 (mono_string_chars (path));

	if (!path_remapped)
		return FALSE;

	mono_gc_wbarrier_generic_store (new_path, (MonoObject*)mono_string_from_utf16_checked (path_remapped, &error));

	g_free (path_remapped);

	mono_error_set_pending_exception (&error);

	return TRUE;
}

const char*
mono_unity_remap_path (const char* path)
{
	const char* path_remap = NULL;
	call_remapper (path, &path_remap);

	return path_remap;
}

const gunichar2*
mono_unity_remap_path_utf16 (const gunichar2* path)
{
	const gunichar2* path_remap = NULL;
	char * utf8_path;
	char * buf;
	char * path_end;
	size_t len;

	if (!g_RemapPathFunc)
		return path_remap;

	utf8_path = g_utf16_to_utf8 (path, -1, NULL, NULL, NULL);
	len = call_remapper (utf8_path, &buf);
	if (len == 0)
	{
		g_free (utf8_path);
		return path_remap;
	}

	path_end = memchr (buf, '\0', len);
	len = path_end ? (size_t)(path_end - buf) : len;

	path_remap = g_utf8_to_utf16 (buf, len, NULL, NULL, NULL);

	g_free (utf8_path);
	g_free (buf);

	return path_remap;
}

MonoMethod*
mono_method_get_method_definition (MonoMethod *method)
{
	while (method->is_inflated)
		method = ((MonoMethodInflated*)method)->declaring;
	return method;
}

gboolean mono_allow_gc_aware_layout = TRUE;

void
mono_class_set_allow_gc_aware_layout(mono_bool allow)
{
	mono_allow_gc_aware_layout = allow;
}

static mono_bool enable_handler_block_guards = TRUE;

void
mono_unity_set_enable_handler_block_guards (mono_bool allow)
{
	enable_handler_block_guards = allow;
}

mono_bool
mono_unity_get_enable_handler_block_guards (void)
{
	return enable_handler_block_guards;
}