//
// Dis VM
// File: module_ref.cpp
// Author: arr
//

#include <runtime.h>
#include <exceptions.h>
#include <vm_memory.h>
#include <utils.h>
#include <debug.h>

using disvm::debug::component_trace_t;
using disvm::debug::log_level_t;

using disvm::runtime::type_descriptor_t;
using disvm::runtime::intrinsic_type_desc;
using disvm::runtime::byte_t;
using disvm::runtime::word_t;
using disvm::runtime::vm_array_t;
using disvm::runtime::vm_string_t;
using disvm::runtime::vm_module_t;
using disvm::runtime::vm_module_ref_t;
using disvm::runtime::export_section_t;
using disvm::runtime::import_vm_module_t;
using disvm::runtime::vm_module_function_ref_t;
using disvm::runtime::vm_system_exception;
using disvm::runtime::vm_user_exception;

namespace
{
    std::unique_ptr<vm_array_t> resolve_imports(const export_section_t &exports, const import_vm_module_t &imports)
    {
        static auto function_ref_type_desc = type_descriptor_t::create(sizeof(vm_module_function_ref_t), std::vector<byte_t>{});
        auto refs = std::make_unique<vm_array_t>(function_ref_type_desc, imports.functions.size());

        for (auto index = std::size_t{ 0 }; index < imports.functions.size(); ++index)
        {
            const auto &import = imports.functions[index];

            const auto exports_with_sig = exports.equal_range(import.sig);
            if (exports_with_sig.first == exports.cend() && exports_with_sig.second == exports.cend())
                throw vm_user_exception{ "Module does not export a function with expected signature" };

            auto export_match = exports_with_sig.first;
            while (export_match != exports_with_sig.second)
            {
                // Look for the matching function name in those with matching signature
                if (0 == vm_string_t::compare(export_match->second.name.get(), import.name.get()))
                    break;

                ++export_match;
            }

            if (export_match == exports_with_sig.second)
                throw vm_user_exception{ "Type check failure for exported function" };

            const auto &export_entry = export_match->second;

            auto &ref = refs->at<vm_module_function_ref_t>(index);
            ref.entry_pc = export_entry.pc;
            ref.frame_type = export_entry.frame_type;

            if (disvm::debug::is_component_tracing_enabled<component_trace_t::module>())
            {
                disvm::debug::log_msg(
                    component_trace_t::module,
                    log_level_t::debug,
                    "export: %d %#08x >>%s<<",
                    index,
                    export_entry.sig,
                    export_entry.name->str());
            }
        }

        return refs;
    }
}

std::shared_ptr<const type_descriptor_t> vm_module_ref_t::type_desc()
{
    return intrinsic_type_desc::type<vm_module_ref_t>();
}

vm_module_ref_t::vm_module_ref_t(std::shared_ptr<const vm_module_t> module)
    : vm_alloc_t(vm_module_ref_t::type_desc())
    , code_section{ module->code_section }
    , module{ module }
    , mp_base{ nullptr }
    , type_section{ module->type_section }
    , _builtin_module{ util::has_flag(module->header.runtime_flag, runtime_flags_t::builtin) }
{
    if (module->original_mp != nullptr)
        mp_base = vm_alloc_t::copy(*module->original_mp);

    if (disvm::debug::is_component_tracing_enabled<component_trace_t::memory>())
        disvm::debug::log_msg(component_trace_t::memory, log_level_t::debug, "init: vm module ref");
}

vm_module_ref_t::vm_module_ref_t(std::shared_ptr<const vm_module_t> module, const import_vm_module_t &imports)
    : vm_alloc_t(vm_module_ref_t::type_desc())
    , code_section{ module->code_section }
    , module{ module }
    , mp_base{ nullptr }
    , type_section{ module->type_section }
    , _function_refs{ resolve_imports(module->export_section, imports) }
    , _builtin_module{ util::has_flag(module->header.runtime_flag, runtime_flags_t::builtin) }
{
    assert(module->header.data_size == 0 || module->original_mp != nullptr);

    if (module->original_mp != nullptr)
        mp_base = vm_alloc_t::copy(*module->original_mp);

    if (disvm::debug::is_component_tracing_enabled<component_trace_t::memory>())
        disvm::debug::log_msg(component_trace_t::memory, log_level_t::debug, "init: vm module ref: exported %d", _function_refs->get_length());
}

vm_module_ref_t::~vm_module_ref_t()
{
    dec_ref_count_and_free(mp_base);

    if (_function_refs != nullptr)
        _function_refs->release();

    if (disvm::debug::is_component_tracing_enabled<component_trace_t::memory>())
        disvm::debug::log_msg(component_trace_t::memory, log_level_t::debug, "destroy: vm module ref");
}

bool vm_module_ref_t::is_builtin_module() const
{
    return _builtin_module;
}

const vm_module_function_ref_t& vm_module_ref_t::get_function_ref(word_t index) const
{
    assert(_function_refs != nullptr);

    if (index < 0 || _function_refs->get_length() <= index)
        throw vm_system_exception{ "Invalid function reference index into module reference functions" };

    return _function_refs->at<vm_module_function_ref_t>(index);
}