#include "il2cpp-config.h"
#include "il2cpp-object-internals.h"
#include "il2cpp-class-internals.h"
#include "icalls/mscorlib/System/Enum.h"
#include "vm/Class.h"
#include "vm/Object.h"
#include "vm/Exception.h"
#include "vm/Reflection.h"
#include "vm/Enum.h"

namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
    Il2CppObject * Enum::get_value(Il2CppObject *thisPtr)
    {
        if (!thisPtr)
            return NULL;

        IL2CPP_ASSERT(thisPtr->klass->enumtype);

        Il2CppClass* enumClass = vm::Class::FromIl2CppType(vm::Class::GetEnumBaseType(thisPtr->klass));
        Il2CppObject* res = vm::Object::New(enumClass);
        void* dst = (char*)res + sizeof(Il2CppObject);
        void* src = (char*)thisPtr + sizeof(Il2CppObject);
        int32_t size = vm::Class::GetValueSize(enumClass, NULL);

        memcpy(dst, src, size);

        return res;
    }

    int Enum::compare_value_to(Il2CppObject * thisPtr, Il2CppObject * other)
    {
        void* tdata = (char*)thisPtr + sizeof(Il2CppObject);
        void* odata = (char*)other + sizeof(Il2CppObject);
        const Il2CppType *basetype = vm::Class::GetEnumBaseType(vm::Object::GetClass(thisPtr));
        IL2CPP_ASSERT(basetype);

#define COMPARE_ENUM_VALUES(ENUM_TYPE) do { \
        ENUM_TYPE me = *((ENUM_TYPE*)tdata); \
        ENUM_TYPE other = *((ENUM_TYPE*)odata); \
        if (me == other) \
            return 0; \
        return me > other ? 1 : -1; \
    } while (0)

#define COMPARE_ENUM_VALUES_RANGE(ENUM_TYPE) do { \
        ENUM_TYPE me = *((ENUM_TYPE*)tdata); \
        ENUM_TYPE other = *((ENUM_TYPE*)odata); \
        if (me == other) \
            return 0; \
        return me - other; \
    } while (0)

        switch (basetype->type)
        {
            case IL2CPP_TYPE_U1:
                COMPARE_ENUM_VALUES(uint8_t);
            case IL2CPP_TYPE_I1:
                COMPARE_ENUM_VALUES(int8_t);
            case IL2CPP_TYPE_CHAR:
                COMPARE_ENUM_VALUES_RANGE(Il2CppChar);
            case IL2CPP_TYPE_U2:
                COMPARE_ENUM_VALUES_RANGE(uint16_t);
            case IL2CPP_TYPE_I2:
                COMPARE_ENUM_VALUES(int16_t);
            case IL2CPP_TYPE_U4:
                COMPARE_ENUM_VALUES(uint32_t);
            case IL2CPP_TYPE_I4:
                COMPARE_ENUM_VALUES(int32_t);
            case IL2CPP_TYPE_U8:
                COMPARE_ENUM_VALUES(uint64_t);
            case IL2CPP_TYPE_I8:
                COMPARE_ENUM_VALUES(int64_t);
            default:
                IL2CPP_ASSERT(false && "Implement type 0x%02x in compare_value_to");
        }

#undef COMPARE_ENUM_VALUES_RANGE
#undef COMPARE_ENUM_VALUES
        return 0;
    }

    int32_t Enum::get_hashcode(Il2CppObject * thisPtr)
    {
        void* data = (char*)thisPtr + sizeof(Il2CppObject);
        Il2CppClass *basetype = thisPtr->klass->element_class;
        IL2CPP_ASSERT(basetype);

        if (basetype == il2cpp_defaults.sbyte_class)
            return *((int8_t*)data);
        if (basetype == il2cpp_defaults.byte_class)
            return *((uint8_t*)data);
        if (basetype == il2cpp_defaults.char_class)
            return *((Il2CppChar*)data);
        if (basetype == il2cpp_defaults.uint16_class)
            return *((uint16_t*)data);
        if (basetype == il2cpp_defaults.int16_class)
            return *((uint16_t*)data);
        if (basetype == il2cpp_defaults.uint32_class)
            return *((uint32_t*)data);
        if (basetype == il2cpp_defaults.int32_class)
            return *((int32_t*)data);
        if (basetype == il2cpp_defaults.uint64_class || basetype == il2cpp_defaults.int64_class)
        {
            int64_t value = *((int64_t*)data);
            return (int32_t)(value & 0xffffffff) ^ (int32_t)(value >> 32);
        }

        IL2CPP_ASSERT(0 && "System_Enum_get_hashcode_icall");
        return 0;
    }

    static uint64_t
    read_enum_value(char *mem, Il2CppClass* type)
    {
        if (type == il2cpp_defaults.byte_class)
            return *(int8_t*)mem;
        if (type == il2cpp_defaults.sbyte_class)
            return *(uint8_t*)mem;
        if (type == il2cpp_defaults.uint16_class)
            return *(uint16_t*)mem;
        if (type == il2cpp_defaults.int16_class)
            return *(int16_t*)mem;
        if (type == il2cpp_defaults.uint32_class)
            return *(uint32_t*)mem;
        if (type == il2cpp_defaults.int32_class)
            return *(int32_t*)mem;
        if (type == il2cpp_defaults.uint64_class)
            return *(uint64_t*)mem;
        if (type == il2cpp_defaults.int64_class)
            return *(int64_t*)mem;

        IL2CPP_ASSERT(0);

        return 0;
    }

    static void
    write_enum_value(char *mem, Il2CppClass* type, uint64_t value)
    {
        if (type == il2cpp_defaults.byte_class || type == il2cpp_defaults.sbyte_class)
        {
            uint8_t *p = (uint8_t*)mem;
            *p = (uint8_t)value;
        }
        else if (type == il2cpp_defaults.uint16_class || type == il2cpp_defaults.int16_class)
        {
            uint16_t *p = (uint16_t*)mem;
            *p = (uint16_t)value;
        }
        else if (type == il2cpp_defaults.uint32_class || type == il2cpp_defaults.int32_class)
        {
            uint32_t *p = (uint32_t*)mem;
            *p = (uint32_t)value;
        }
        else if (type == il2cpp_defaults.uint64_class || type == il2cpp_defaults.int64_class)
        {
            uint64_t *p = (uint64_t*)mem;
            *p = value;
        }
        else
        {
            IL2CPP_ASSERT(0);
        }
    }

    Il2CppObject * Enum::ToObject(Il2CppReflectionType * enumType, Il2CppObject * value)
    {
        //MonoDomain *domain;
        Il2CppClass *enumc, *objc;
        Il2CppObject *res;
        Il2CppClass *etype;
        uint64_t val;

        IL2CPP_CHECK_ARG_NULL(enumType);
        IL2CPP_CHECK_ARG_NULL(value);

        //domain = mono_object_domain (enumType);
        enumc = vm::Class::FromIl2CppType(enumType->type);
        objc = vm::Object::GetClass(value);

        //if (!enumc->enumtype)
        //  mono_raise_exception (mono_get_exception_argument ("enumType", "Type provided must be an Enum."));
        //if (!((objc->enumtype) || (objc->byval_arg.type >= MONO_TYPE_I1 && objc->byval_arg.type <= MONO_TYPE_U8)))
        //  mono_raise_exception (mono_get_exception_argument ("value", "The value passed in must be an enum base or an underlying type for an enum, such as an Int32."));

        etype = vm::Class::GetElementClass(enumc);
        if (!etype)
            /* MS throws this for typebuilders */
            il2cpp::vm::Exception::Raise(il2cpp::vm::Exception::GetArgumentException("Type must be a type provided by the runtime.", "enumType"));

        res = (Il2CppObject*)il2cpp::vm::Object::New(enumc);
        //val = read_enum_value ((char *)value + sizeof (mscorlib_System_Object), objc->enumtype? mono_class_enum_basetype (objc)->type: objc->byval_arg.type);
        val = read_enum_value((char*)value + sizeof(Il2CppObject), objc->enumtype ? objc->element_class : objc);
        write_enum_value((char*)res + sizeof(Il2CppObject), etype, val);

        return res;
    }

    Il2CppReflectionType * Enum::get_underlying_type(Il2CppReflectionType *type)
    {
        const Il2CppType *etype;

        etype = vm::Class::GetEnumBaseType(vm::Class::FromIl2CppType(type->type));
        if (!etype)
            /* MS throws this for typebuilders */
            il2cpp::vm::Exception::Raise(il2cpp::vm::Exception::GetArgumentException("Type must be a type provided by the runtime.", "enumType"));

        return il2cpp::vm::Reflection::GetTypeObject(etype);
    }

    bool Enum::GetEnumValuesAndNames(Il2CppReflectionRuntimeType* enumType, Il2CppArray** values, Il2CppArray** names)
    {
        return vm::Enum::GetEnumValuesAndNames(vm::Class::FromIl2CppType(enumType->type.type), values, names);
    }

    bool Enum::InternalHasFlag(Il2CppObject* thisPtr, Il2CppObject* flags)
    {
        Il2CppClass* enumClass = vm::Class::FromIl2CppType(vm::Class::GetEnumBaseType(thisPtr->klass));
        int32_t size = vm::Class::GetValueSize(enumClass, NULL);
        uint64_t a_val = 0, b_val = 0;

        memcpy(&a_val, vm::Object::Unbox(thisPtr), size);
        memcpy(&b_val, vm::Object::Unbox(flags), size);

        return (a_val & b_val) == b_val;
    }

    int32_t Enum::InternalCompareTo(Il2CppObject* o1, Il2CppObject* o2)
    {
        return compare_value_to(o1, o2);
    }

    Il2CppObject* Enum::InternalBoxEnum(Il2CppReflectionRuntimeType* enumType, int64_t value)
    {
        return vm::Object::Box(vm::Class::FromIl2CppType(enumType->type.type), &value);
    }

    Il2CppReflectionRuntimeType* Enum::InternalGetUnderlyingType(Il2CppReflectionRuntimeType* enumType)
    {
        return reinterpret_cast<Il2CppReflectionRuntimeType*>(get_underlying_type(&enumType->type));
    }

#if IL2CPP_TINY
    bool Enum::TinyEnumEquals(Il2CppObject* left, Il2CppObject* right)
    {
        if (left->klass != right->klass)
            return false;

        return compare_value_to(left, right) == 0;
    }

#endif
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */