#include "il2cpp-config.h"
#include <stddef.h>
#include "gc/GarbageCollector.h"
#include "icalls/mscorlib/System.Reflection/MonoField.h"
#include "utils/StringUtils.h"
#include "vm/Class.h"
#include "vm/Field.h"
#include "vm/Object.h"
#include "vm/Reflection.h"
#include "vm/Runtime.h"
#include "vm/Type.h"
#include "vm/Exception.h"
#include "il2cpp-class-internals.h"
#include "il2cpp-tabledefs.h"
#include "vm-utils/BlobReader.h"

#include "hybridclr/metadata/MetadataUtil.h"

using il2cpp::utils::StringUtils;

namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Reflection
{
    Il2CppReflectionType * MonoField::GetParentType(Il2CppReflectionField * field, bool declaring)
    {
        Il2CppClass *parent;

        parent = declaring ? field->field->parent : field->klass;

        return il2cpp::vm::Reflection::GetTypeObject(&parent->byval_arg);
    }

    int32_t MonoField::GetFieldOffset(Il2CppReflectionField * field)
    {
        return field->field->offset - sizeof(Il2CppObject);
    }

    Il2CppObject* MonoField::GetValueInternal(Il2CppReflectionField * field, Il2CppObject * obj)
    {
        return vm::Field::GetValueObject(field->field, obj);
    }

    void MonoField::SetValueInternal(Il2CppReflectionField* field, Il2CppObject* obj, Il2CppObject* value)
    {
        ::FieldInfo* fieldInfo = field->field;
        Il2CppClass* fieldType = vm::Class::FromIl2CppType(fieldInfo->type);
        vm::Class::Init(fieldType);

        uint8_t* fieldAddress;

        if (fieldInfo->type->attrs & FIELD_ATTRIBUTE_STATIC)
        {
            if (fieldInfo->offset == THREAD_STATIC_FIELD_OFFSET)
            {
                IL2CPP_NOT_IMPLEMENTED(Field::StaticSetValue);
            }

            vm::Runtime::ClassInit(fieldInfo->parent);
            fieldAddress = static_cast<uint8_t*>(fieldInfo->parent->static_fields) + fieldInfo->offset;
        }
        else
        {
            IL2CPP_ASSERT(obj);
            fieldAddress = reinterpret_cast<uint8_t*>(obj) + fieldInfo->offset;
        }

        if (fieldType->valuetype)
        {
            if (!vm::Class::IsNullable(fieldType))
            {
                uint32_t fieldSize = vm::Class::GetInstanceSize(fieldType) - sizeof(Il2CppObject);

                if (value != NULL)
                {
                    memcpy(fieldAddress, vm::Object::Unbox(value), fieldSize);
                }
                else
                {
                    // Setting value type to null is defined to zero it out
                    memset(fieldAddress, 0, fieldSize);
                }
                il2cpp::gc::GarbageCollector::SetWriteBarrier((void**)fieldAddress, fieldSize);
            }
            else
            {
                Il2CppClass* nullableArg = vm::Class::GetNullableArgument(fieldType);
                uint32_t valueSize = vm::Class::GetInstanceSize(nullableArg) - sizeof(Il2CppObject);

                if (value != NULL)
                {
                    memcpy(fieldAddress, vm::Object::Unbox(value), valueSize);
                    *(fieldAddress + valueSize) = true;
                }
                else
                {
                    *(fieldAddress + valueSize) = false;
                }
                il2cpp::gc::GarbageCollector::SetWriteBarrier((void**)fieldAddress, valueSize);
            }
        }
        else
        {
            memcpy(fieldAddress, &value, sizeof(Il2CppObject*));
            il2cpp::gc::GarbageCollector::SetWriteBarrier((void**)fieldAddress);
        }
    }

    Il2CppObject* MonoField::GetRawConstantValue(Il2CppReflectionField* field)
    {
        ::FieldInfo* fieldInfo = field->field;

        if (!(fieldInfo->type->attrs & FIELD_ATTRIBUTE_HAS_DEFAULT))
            vm::Exception::Raise(vm::Exception::GetInvalidOperationException(NULL));

        const Il2CppType* type = NULL;
        const char* data = vm::Class::GetFieldDefaultValue(fieldInfo, &type);

        bool useCompressBlobSize = hybridclr::metadata::IsInterpreterType(fieldInfo->parent);
        switch (type->type)
        {
            case IL2CPP_TYPE_U1:
            case IL2CPP_TYPE_I1:
            case IL2CPP_TYPE_BOOLEAN:
            case IL2CPP_TYPE_U2:
            case IL2CPP_TYPE_I2:
            case IL2CPP_TYPE_CHAR:
            case IL2CPP_TYPE_U4:
            case IL2CPP_TYPE_I4:
            case IL2CPP_TYPE_R4:
            case IL2CPP_TYPE_U8:
            case IL2CPP_TYPE_I8:
            case IL2CPP_TYPE_R8:
            {
                Il2CppObject* obj = vm::Object::New(vm::Class::FromIl2CppType(type));
                utils::BlobReader::GetConstantValueFromBlob(type->type, data, vm::Object::Unbox(obj), useCompressBlobSize);
                return obj;
            }
            case IL2CPP_TYPE_STRING:
            case IL2CPP_TYPE_CLASS:
            case IL2CPP_TYPE_OBJECT:
            case IL2CPP_TYPE_GENERICINST:
            {
                Il2CppObject* obj = NULL;
                utils::BlobReader::GetConstantValueFromBlob(type->type, data, &obj, useCompressBlobSize);
                return obj;
            }
            default:
                vm::Exception::Raise(vm::Exception::GetInvalidOperationException(StringUtils::Printf("Attempting to get raw constant value for field of type %d", type).c_str()));
        }

        return NULL;
    }

    int32_t MonoField::get_core_clr_security_level(Il2CppObject* _this)
    {
        IL2CPP_NOT_IMPLEMENTED_ICALL(MonoField::get_core_clr_security_level);
        IL2CPP_UNREACHABLE;
        return 0;
    }

    Il2CppObject* MonoField::ResolveType(Il2CppObject* _this)
    {
        IL2CPP_NOT_IMPLEMENTED_ICALL(MonoField::ResolveType);
        IL2CPP_UNREACHABLE;
        return NULL;
    }
} /* namespace Reflection */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */