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

#include <cassert>
#include <memory>
#include <algorithm>
#include <disvm.h>
#include <debug.h>
#include <runtime.h>
#include <exceptions.h>
#include <builtin_module.h>
#include <vm_version.h>
#include "scheduler.h"
#include "garbage_collector.h"

using namespace disvm;
using namespace disvm::runtime;

vm_t::loaded_module_t::loaded_module_t(std::unique_ptr<runtime::vm_string_t> origin, std::shared_ptr<const runtime::vm_module_t> module)
    : origin{ std::move(origin) }
    , module{ module }
{
    assert(this->origin != nullptr);
}

vm_t::loaded_module_t::loaded_module_t(loaded_module_t &&other)
    : origin{ std::move(other.origin) }
    , module{ std::move(other.module) }
{
}

vm_t::loaded_module_t::~loaded_module_t()
{
    if (origin != nullptr)
        origin->release();
}

vm_t::vm_t(
    create_vm_interface_callback_t<runtime::vm_scheduler_t> create_scheduler,
    create_vm_interface_callback_t<runtime::vm_garbage_collector_t> create_gc)
{
    // Initialize built-in modules.
    builtin::initialize_builtin_modules();

    if (create_gc == nullptr)
        _gc = std::make_unique<default_garbage_collector_t>(*this);
    else
        _gc = create_gc(*this);

    if (create_scheduler == nullptr)
    {
        const auto system_thread_count = uint32_t{ 1 };

        // The Inferno implementation defined the thread quanta as 2048 (include/interp.h)
        const auto thread_quanta = uint32_t{ 2048 };

        _scheduler = std::make_unique<default_scheduler_t>(*this, system_thread_count, thread_quanta);
    }
    else
    {
        _scheduler = create_scheduler(*this);
    }
}

vm_t::vm_t(uint32_t system_thread_count, uint32_t thread_quanta)
{
    // Initialize built-in modules.
    builtin::initialize_builtin_modules();

    _gc = std::make_unique<default_garbage_collector_t>(*this);
    _scheduler = std::make_unique<default_scheduler_t>(*this, system_thread_count, thread_quanta);
}

vm_t::~vm_t()
{
    // Release the scheduler first since it could be using the gc instance.
    _scheduler.reset();
    _gc.reset();
}

vm_version_t vm_t::get_version() const
{
    return{ DISVM_VERSION_MAJOR, DISVM_VERSION_MINOR, DISVM_VERSION_PATCH, DISVM_VERSION_LABEL };
}

namespace
{
    const runtime::vm_thread_t& _exec(runtime::vm_scheduler_t &s, std::unique_ptr<runtime::vm_module_ref_t> &entry_module_ref)
    {
        auto thread = std::make_unique<vm_thread_t>(*entry_module_ref, vm_t::root_vm_thread_id);

        // Now that the thread has been created and has inherited ownership of the pointer, relinquish the smart pointer's ownership.
        entry_module_ref->release(); // decrement the vm alloc ref count
        entry_module_ref.release(); // release the smart pointer

        return s.schedule_thread(std::move(thread));
    }
}

const runtime::vm_thread_t& vm_t::exec(const char *path)
{
    assert(path != nullptr);
    auto entry_module = load_module(path);

    auto entry_module_ref = std::make_unique<vm_module_ref_t>(entry_module);
    return _exec(*_scheduler, entry_module_ref);
}

const runtime::vm_thread_t& vm_t::exec(std::unique_ptr<runtime::vm_module_t> entry_module)
{
    assert(entry_module != nullptr);

    auto entry_module_ref = std::make_unique<vm_module_ref_t>(std::move(entry_module));
    return _exec(*_scheduler, entry_module_ref);
}

const runtime::vm_thread_t& vm_t::fork(
    const runtime::vm_thread_t &parent,
    runtime::vm_module_ref_t &module_ref,
    const runtime::vm_frame_t &initial_frame,
    runtime::vm_pc_t initial_pc)
{
    if (initial_pc < 0 || static_cast<vm_pc_t>(module_ref.code_section.size()) <= initial_pc)
        throw vm_system_exception{ "Invalid entry program counter" };

    auto thread = std::make_unique<vm_thread_t>(module_ref, initial_frame, initial_pc, parent.get_thread_id());
    return _scheduler->schedule_thread(std::move(thread));
}

std::shared_ptr<const runtime::vm_module_t> vm_t::load_module(const char *path)
{
    if (path == nullptr)
        throw vm_user_exception{ "Invalid module path" };

    std::lock_guard<std::mutex> lock{ _modules_lock };
    
    // Check if the module is already loaded.
    auto iter = std::begin(_modules);
    while (iter != std::end(_modules))
    {
        if (0 == ::strcmp(iter->origin->str(), path))
        {
            auto module = iter->module.lock();

            // If an entry exists but is null, the module was loaded before. Read the module again and return.
            if (module == nullptr)
            {
                module = std::shared_ptr<vm_module_t>{ std::move(read_module(path)) };
                iter->module = module;

                debug::log_msg(debug::component_trace_t::module, debug::log_level_t::debug, "reload: vm module: >>%s<<\n", path);
            }

            return module;
        }

        ++iter;
    }

    auto new_module = std::shared_ptr<vm_module_t>{};
    if (path[0] == BUILTIN_MODULE_PREFIX_CHAR)
    {
        new_module = std::move(builtin::get_builtin_module(path));
    }
    else
    {
        // Read in the module
        new_module = std::move(read_module(path));
    }

    auto path_local = std::make_unique<vm_string_t>(std::strlen(path), reinterpret_cast<const uint8_t *>(path));
    _modules.push_front(std::move(loaded_module_t{ std::move(path_local), new_module }));

    debug::log_msg(debug::component_trace_t::module, debug::log_level_t::debug, "load: vm module: >>%s<<\n", path);

    return new_module;
}

runtime::vm_scheduler_control_t &vm_t::get_scheduler_control() const
{
    return _scheduler->get_controller();
}

runtime::vm_garbage_collector_t &vm_t::get_garbage_collector() const
{
    return *_gc;
}

void vm_t::spin_sleep_till_idle(std::chrono::milliseconds sleep_interval) const
{
    do
        std::this_thread::sleep_for(sleep_interval);
    while (!_scheduler->is_idle());
}