#include "mono.hpp"
#include <mono/metadata/appdomain.h>

namespace Mono {

template <> MonoClass* getClass<SByte>(){ return mono_get_sbyte_class(); }
template <> MonoClass* getClass<Byte>(){ return mono_get_byte_class(); }
template <> MonoClass* getClass<Short>(){ return mono_get_int16_class(); }
template <> MonoClass* getClass<UShort>(){ return mono_get_uint16_class(); }
template <> MonoClass* getClass<Int>(){ return mono_get_int32_class(); }
template <> MonoClass* getClass<UInt>(){ return mono_get_uint32_class(); }
template <> MonoClass* getClass<Long>(){ return mono_get_int64_class(); }
template <> MonoClass* getClass<ULong>(){ return mono_get_uint64_class(); }
template <> MonoClass* getClass<Float>(){ return mono_get_single_class(); }
template <> MonoClass* getClass<Double>(){ return mono_get_double_class(); }
template <> MonoClass* getClass<Bool>(){ return mono_get_boolean_class(); }
template <> MonoClass* getClass<Char>(){ return mono_get_char_class(); }
template <> MonoClass* getClass<String>(){ return mono_get_string_class(); }
template <> MonoClass* getClass<Object>(){ return mono_get_object_class(); }
template <> MonoClass* getClass<Void>(){ return mono_get_void_class(); }


void getMethodSignatureTypes(MonoMethod* mono_method,
        MonoType** return_type,
        std::vector<MonoType*>& argument_types)
{
    auto signature = mono_method_signature(mono_method);
    void* iter = nullptr;
    *return_type = mono_signature_get_return_type(signature);
    MonoType* pt = nullptr;
    while( (pt = mono_signature_get_params(signature, &iter)) ){
        argument_types.push_back(pt);
    }
}

MonoMethod* tryGetMonoMethod(MonoClass* target_class, const std::string& name,
        MonoClass* return_class, MonoClass* arg_classes[], size_t arg_classes_size)
{
    if(target_class == nullptr)
        throw UsefulException("target_class is nullptr");
    
    // iterate each method
    void* iter = nullptr;
    MonoMethod* m = nullptr;
    std::vector<MonoType*> argument_types;
    while( (m = mono_class_get_methods(target_class, &iter)) ){
        // compare name
        std::string m_name = mono_method_get_name(m);
        if(m_name != name)
            continue;
        
        argument_types.clear();
        MonoType* return_type = nullptr;
        getMethodSignatureTypes(m, &return_type, argument_types);
        // compare argument count
        if(argument_types.size() != arg_classes_size)
            continue;
        
        // compare return type
        if(!mono_metadata_type_equal(return_type, mono_class_get_type(return_class)))
            continue;
        
        // compare argument types
        bool argument_types_mismatch = false;
        for(size_t i = 0; i < arg_classes_size; i++){
            if(!mono_metadata_type_equal(argument_types[i], mono_class_get_type(arg_classes[i]))){
                argument_types_mismatch = true;
                break;
            }
        }
        if(argument_types_mismatch)
            continue;
        
        // passed all tests successfully
        break;
    }

    return m;
}

}