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

#include <cassert>
#include <vector>
#include <debug.h>
#include <vm_tools.h>
#include <exceptions.h>
#include <utils.h>
#include "tool_dispatch.h"

using namespace disvm;
using namespace disvm::runtime;

// Empty destructor for vm tool 'interface'
vm_tool_t::~vm_tool_t()
{
}

vm_tool_dispatch_t::vm_tool_dispatch_t(vm_t &vm)
    : _vm{ vm }
{
    _events.cookie_counter = 1;
    _breakpoints.cookie_counter = 1;
}

vm_tool_dispatch_t::~vm_tool_dispatch_t()
{
    std::lock_guard<std::mutex> lock{ _tools_lock };
    for (auto &t : _tools)
        t.second->on_unload();
}

std::size_t vm_tool_dispatch_t::load_tool(std::shared_ptr<runtime::vm_tool_t> tool)
{
    static std::size_t _tool_id_counter{ 1 };

    if (tool == nullptr)
        throw vm_system_exception{ "Tool cannot be null" };

    // Keep the lock for the collection until the tool has been completed being loaded.
    std::lock_guard<std::mutex> lock{ _tools_lock };
    const auto current_id = _tool_id_counter++;
    _tools[current_id] = tool;

    try
    {
        // [TODO] For debug builds, it might be useful to wrap the controller in a proxy that records
        // the subscribed callbacks and asserts they are all properly unsubscribed during agent unload.
        tool->on_load(*this, current_id);
    }
    catch (...)
    {
        if (debug::is_component_tracing_enabled<debug::component_trace_t::tool>())
            debug::log_msg(debug::component_trace_t::tool, debug::log_level_t::warning, "load: tool: failure");

        // The ID is tainted and will not be re-used
        _tools.erase(current_id);
        throw;
    }

    if (debug::is_component_tracing_enabled<debug::component_trace_t::tool>())
        debug::log_msg(debug::component_trace_t::tool, debug::log_level_t::debug, "load: tool: %d", current_id);

    return current_id;
}

std::size_t vm_tool_dispatch_t::unload_tool(std::size_t tool_id)
{
    // Keep the lock for the collection until the tool has been completed being unloaded.
    std::lock_guard<std::mutex> lock{ _tools_lock };
    auto iter = _tools.find(tool_id);
    if (iter == _tools.cend())
        return _tools.size();

    auto tool = iter->second;
    _tools.erase(iter);

    if (debug::is_component_tracing_enabled<debug::component_trace_t::tool>())
        debug::log_msg(debug::component_trace_t::tool, debug::log_level_t::debug, "unload: tool: %d", tool_id);

    assert(tool != nullptr);
    tool->on_unload();

    return _tools.size();
}

opcode_t vm_tool_dispatch_t::on_breakpoint(vm_registers_t &r)
{
    opcode_t original_op;
    cookie_t cookie_id;
    std::tie(original_op, cookie_id) = get_original_opcode_and_cookie(r);

    vm_event_context_t cxt{};
    cxt.value1.registers = &r;
    cxt.value2.cookie = cookie_id;

    _events.fire_event_callbacks(vm_event_t::breakpoint, cxt);

    return original_op;
}

void vm_tool_dispatch_t::on_exception_raised(vm_registers_t &r, const vm_string_t &id, vm_alloc_t &e)
{
    vm_event_context_t cxt{};
    cxt.value1.registers = &r;
    cxt.value2.str = &id;
    cxt.value3.alloc = &e;

    _events.fire_event_callbacks(vm_event_t::exception_raised, cxt);
}

void vm_tool_dispatch_t::on_exception_unhandled(vm_registers_t &r, const vm_string_t &id, vm_alloc_t &e)
{
    vm_event_context_t cxt{};
    cxt.value1.registers = &r;
    cxt.value2.str = &id;
    cxt.value3.alloc = &e;

    _events.fire_event_callbacks(vm_event_t::exception_unhandled, cxt);
}

void vm_tool_dispatch_t::on_module_vm_load(std::shared_ptr<vm_module_t> &m, const vm_string_t &path)
{
    assert(m != nullptr);

    vm_event_context_t cxt{};
    cxt.value1.module = &m;
    cxt.value2.str = &path;

    _events.fire_event_callbacks(vm_event_t::module_vm_load, cxt);
}

void vm_tool_dispatch_t::on_module_thread_load(vm_registers_t &r, std::shared_ptr<vm_module_t> &m)
{
    assert(m != nullptr);

    vm_event_context_t cxt{};
    cxt.value1.registers = &r;
    cxt.value2.module = &m;

    _events.fire_event_callbacks(vm_event_t::module_thread_load, cxt);
}

void vm_tool_dispatch_t::on_thread_begin(vm_thread_t &t)
{
    vm_event_context_t cxt{};
    cxt.value1.thread = &t;

    _events.fire_event_callbacks(vm_event_t::thread_begin, cxt);
}

void vm_tool_dispatch_t::on_thread_end(vm_thread_t &t)
{
    vm_event_context_t cxt{};
    cxt.value1.thread = &t;

    _events.fire_event_callbacks(vm_event_t::thread_end, cxt);
}

vm_t& vm_tool_dispatch_t::get_vm_instance() const
{
    return _vm;
}

cookie_t vm_tool_dispatch_t::subscribe_event(vm_event_t evt, vm_event_callback_t cb)
{
    if (!cb)
        throw vm_system_exception{ "Invalid callback for event" };

    std::lock_guard<std::mutex> lock{ _events.lock };

    const auto cookie_id = _events.cookie_counter++;

    // Store the event callback
    auto &event_callbacks = _events.callbacks[evt];
    event_callbacks[cookie_id] = cb;

    // Store the cookie with the associate event
    _events.cookie_to_event[cookie_id] = evt;

    if (debug::is_component_tracing_enabled<debug::component_trace_t::tool>())
        debug::log_msg(debug::component_trace_t::tool, debug::log_level_t::debug, "subscribe: event: %d %d", evt, cookie_id);

    return cookie_id;
}

void vm_tool_dispatch_t::unsubscribe_event(cookie_t cookie_id)
{
    std::lock_guard<std::mutex> lock{ _events.lock };

    auto iter = _events.cookie_to_event.find(cookie_id);
    if (iter == _events.cookie_to_event.cend())
        return;

    // Erase cookie and event
    const auto evt = iter->second;
    auto &event_callbacks = _events.callbacks[evt];
    event_callbacks.erase(cookie_id);
    _events.cookie_to_event.erase(iter);

    if (debug::is_component_tracing_enabled<debug::component_trace_t::tool>())
        debug::log_msg(debug::component_trace_t::tool, debug::log_level_t::debug, "unsubscribe: event: %d %d", evt, cookie_id);
}

cookie_t vm_tool_dispatch_t::set_breakpoint(std::shared_ptr<vm_module_t> module, vm_pc_t pc)
{
    if (module == nullptr || util::has_flag(module->header.runtime_flag, runtime_flags_t::builtin))
        throw vm_system_exception{ "Unable to set breakpoint in supplied module" };

    auto &code_section = module->code_section;
    if (pc >= static_cast<vm_pc_t>(code_section.size()))
        throw vm_system_exception{ "Invalid PC for module" };

    const auto real_opcode = code_section[pc].op.opcode;

    {
        std::lock_guard<std::mutex> lock{ _breakpoints.lock };
        if (real_opcode == opcode_t::brkpt)
            throw vm_system_exception{ "Breakpoint already set at PC" };

        const auto cookie_id = _breakpoints.cookie_counter++;

        // Map the cookie to the module/pc pair.
        _breakpoints.cookie_to_details[cookie_id] = { module, pc };

        // Record the original opcode
        auto &pc_map = _breakpoints.original_opcodes[reinterpret_cast<std::uintptr_t>(module.get())];
        pc_map[pc] = std::make_pair(real_opcode, cookie_id);

        // Replace the current opcode with breakpoint
        code_section[pc].op.opcode = opcode_t::brkpt;

        if (debug::is_component_tracing_enabled<debug::component_trace_t::tool>())
            debug::log_msg(debug::component_trace_t::tool, debug::log_level_t::debug, "breakpoint: set: %d %d >>%s<<", cookie_id, pc, module->module_name->str());

        return cookie_id;
    }
}

breakpoint_details_t vm_tool_dispatch_t::get_breakpoint_details(cookie_t cookie_id) const
{
    std::lock_guard<std::mutex> lock{ _breakpoints.lock };

    auto iter_cookie = _breakpoints.cookie_to_details.find(cookie_id);
    if (iter_cookie == _breakpoints.cookie_to_details.cend())
        throw vm_system_exception{ "Unknown breakpoint cookie" };

    return iter_cookie->second;
}

void vm_tool_dispatch_t::clear_breakpoint(cookie_t cookie_id)
{
    std::lock_guard<std::mutex> lock{ _breakpoints.lock };

    auto iter_cookie = _breakpoints.cookie_to_details.find(cookie_id);
    if (iter_cookie == _breakpoints.cookie_to_details.cend())
        throw vm_system_exception{ "Unknown breakpoint cookie" };

    auto details = iter_cookie->second;
    const auto target_pc = details.pc;

    // Determine the original opcode
    auto iter_orig = _breakpoints.original_opcodes.find(reinterpret_cast<std::uintptr_t>(details.module.get()));
    assert(iter_orig != _breakpoints.original_opcodes.cend());

    auto &pc_map = iter_orig->second;
    auto iter_pc = pc_map.find(target_pc);
    assert(iter_pc != pc_map.cend());
    
    auto original_opcode = iter_pc->second.first;

    // Replace the breakpoint opcode with the original
    auto &code_section = const_cast<code_section_t &>(details.module->code_section);
    assert(code_section[target_pc].op.opcode == opcode_t::brkpt);
    code_section[target_pc].op.opcode = original_opcode;

    if (debug::is_component_tracing_enabled<debug::component_trace_t::tool>())
        debug::log_msg(debug::component_trace_t::tool, debug::log_level_t::debug, "breakpoint: unset: %d %d >>%s<<", cookie_id, target_pc, details.module->module_name->str());

    // Clean-up the PC mapping to opcode
    pc_map.erase(iter_pc);

    // If the PC map is empty, erase the module mapping as well
    if (pc_map.size() == 0)
        _breakpoints.original_opcodes.erase(iter_orig);

    // Remove the cookie map
    _breakpoints.cookie_to_details.erase(iter_cookie);
}

std::tuple<opcode_t, cookie_t> vm_tool_dispatch_t::get_original_opcode_and_cookie(const vm_registers_t &r)
{
    const auto module = r.module_ref->module.get();
    const auto current_pc = r.pc - 1;

    if (module == nullptr || util::has_flag(module->header.runtime_flag, runtime_flags_t::builtin))
        throw vm_system_exception{ "Unable to determine original opcode in supplied module" };

    std::lock_guard<std::mutex> lock{ _breakpoints.lock };

    auto iter_orig = _breakpoints.original_opcodes.find(reinterpret_cast<std::uintptr_t>(module));
    if (iter_orig != _breakpoints.original_opcodes.cend())
    {
        auto &pc_map = iter_orig->second;
        auto iter_pc = pc_map.find(current_pc);
        if (iter_pc != pc_map.cend())
            return iter_pc->second;
    }

    assert(false && "Why are we missing this information?");
    return std::make_tuple(opcode_t::runt, 0); // Return NOP instruction?
}

void vm_tool_dispatch_t::events_t::fire_event_callbacks(vm_event_t event_type, vm_event_context_t &cxt)
{
    auto event_callbacks = std::vector<vm_event_callback_t>{};

    {
        std::lock_guard<std::mutex> lock_local{ lock };

        auto &event_callbacks_tmp = callbacks[event_type];
        for (auto &c : event_callbacks_tmp)
        {
            assert(static_cast<bool>(c.second) && "Why is callback empty?");
            event_callbacks.push_back(c.second);
        }
    }

    for (auto &c : event_callbacks)
        c(event_type, cxt);
}