//
// Dis VM
// File: disvm.h
// Author: arr
//

#ifndef _DISVM_SRC_INCLUDE_DISVM_H_
#define _DISVM_SRC_INCLUDE_DISVM_H_

#include <array>
#include <iosfwd>
#include <memory>
#include <functional>
#include <mutex>
#include <forward_list>
#include "runtime.h"
#include "exceptions.h"

namespace disvm
{
    // Read in a module from the supplied stream
    std::unique_ptr<runtime::vm_module_t> read_module(std::istream &data);

    template <typename C>
    using create_vm_interface_callback_t = std::unique_ptr<C>(*)(vm_t &);

    // VM version structure
    // Adheres to the semantic versioning scheme found at http://semver.org/
    struct vm_version_t final
    {
        const uint32_t major;
        const uint32_t minor;
        const uint32_t patch;
        const char * const label; // Optional
    };

    // Loaded module reference
    class loaded_vm_module_t final
    {
    public:
        runtime::module_id_t vm_id;

        // Origin of module
        std::unique_ptr<runtime::vm_string_t> origin;

        // Weak reference to a loaded module
        std::weak_ptr<runtime::vm_module_t> module;
    };

    // Callback for enumerating loaded modules - return 'false' to stop enumeration, otherwise 'true'
    using loaded_vm_module_callback_t = std::function<bool(const loaded_vm_module_t&)>;

    // Configuration for the created VM
    class vm_config_t final
    {
    public:
        vm_config_t();
        vm_config_t(vm_config_t &&);

        // Settings for the default scheduler. Only used if create_scheduler is not set.
        // Both of these values are initialized to valid default values on construction.
        uint32_t sys_thread_pool_size;
        uint32_t thread_quanta;

        create_vm_interface_callback_t<runtime::vm_scheduler_t> create_scheduler;
        create_vm_interface_callback_t<runtime::vm_garbage_collector_t> create_gc;

        // Prefix paths used by the default module resolver if the path supplied by
        // the user isn't found. Note these will be concatenated with the supplied
        // path, not other manipulation will be performed.
        std::vector<std::string> probing_paths;
        std::vector<std::unique_ptr<runtime::vm_module_resolver_t>> additional_resolvers;
    };

    // Virtual machine
    class vm_t final
    {
    public: // static
        static const uint32_t root_vm_thread_id;

    public:
        explicit vm_t();
        explicit vm_t(vm_config_t config);

        ~vm_t();

    public:
        // Get the VM version.
        // All fields on the output structure will be set.
        vm_version_t get_version() const;

        // Begin execution of the module at the supplied path and return the ID of
        // the executing thread.
        uint32_t exec(const char *path);

        // Begin execution of the supplied module and return the ID of the executing thread.
        uint32_t exec(std::unique_ptr<runtime::vm_module_t> entry_module);

        // Begin execution of a child thread in the supplied module at the indicated
        // program counter and return the ID of the executing thread.
        uint32_t fork(
            const uint32_t parent_tid,
            runtime::vm_module_ref_t &module_ref,
            const runtime::vm_frame_t &initial_frame,
            runtime::vm_pc_t initial_pc);

        // Load the module at the supplied path into the virtual machine.
        std::shared_ptr<runtime::vm_module_t> load_module(const char *path);

        // Enumerate all loaded modules - this can include references to modules that
        // have been unloaded due to no longer being used. If the module instance is null, the
        // module is no longer loaded.
        // Note this will only enumerate modules that have been loaded via a path.
        void enum_loaded_modules(loaded_vm_module_callback_t callback) const;

        // Access the scheduler control for this VM.
        runtime::vm_scheduler_control_t &get_scheduler_control() const;

        // Access the garbage collector for this VM.
        runtime::vm_garbage_collector_t &get_garbage_collector() const;

        // Spin and sleep until the VM is idle, then return.
        // Idle is defined as no vm threads executing, scheduled to be executed, or blocked.
        void spin_sleep_till_idle(std::chrono::milliseconds sleep_interval) const;

        // Loads a tool into the VM
        std::size_t load_tool(std::shared_ptr<runtime::vm_tool_t> tool);

        // Unloads the tool associated with the supplied ID
        void unload_tool(std::size_t tool_id);

    private:
        void schedule_thread(std::unique_ptr<runtime::vm_thread_t> thread);

        using loaded_modules_t = std::forward_list<loaded_vm_module_t>;
        mutable std::mutex _modules_lock;
        loaded_modules_t _modules;

        std::vector<std::unique_ptr<runtime::vm_module_resolver_t>> _module_resolvers;
        std::unique_ptr<runtime::vm_scheduler_t> _scheduler;
        std::unique_ptr<runtime::vm_garbage_collector_t> _gc;
        std::unique_ptr<runtime::vm_tool_dispatch_t> _tool_dispatch;
        std::mutex _tool_dispatch_lock;

        std::atomic_flag _last_syscall_error_message_lock;
        std::array<char, 128> _last_syscall_error_message;

        friend void disvm::runtime::push_syscall_error_message(disvm::vm_t &, const char *) noexcept;
        friend std::string disvm::runtime::pop_syscall_error_message(disvm::vm_t &);
    };
}

#endif // _DISVM_SRC_INCLUDE_DISVM_H_