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

#include <cinttypes>
#include <array>
#include <utf8.h>
#include "sys_utils.h"

using disvm::runtime::byte_t;
using disvm::runtime::pointer_t;
using disvm::runtime::vm_array_t;
using disvm::runtime::word_t;

namespace
{
    // Align the supplied pointer for the template type relative to base.
    template<typename T>
    byte_t *align_for(byte_t *p, pointer_t base)
    {
        for (;;)
        {
            const auto d = reinterpret_cast<std::uintptr_t>(p) - reinterpret_cast<std::uintptr_t>(base);
            if (d % sizeof(T) == 0)
                return p;

            p++;
        }
    }
}

// Shamelessly adopted and altered from Inferno implementation (xprint - libinterp/runt.c)
// [TODO] Handle UTF-8, binary format 'B'
word_t disvm::runtime::sys::printf_to_buffer(
    disvm::vm_t &vm,
    const disvm::runtime::vm_string_t &msg_fmt,
    disvm::runtime::byte_t *msg_args,
    disvm::runtime::pointer_t base,
    const std::size_t buffer_size,
    char *buffer)
{
    auto b_curr = buffer;
    const auto b_end = buffer + (buffer_size - 1);
    const auto fmt_len = msg_fmt.get_length();
    auto i = word_t{ 0 };

    auto format = std::vector<char>{};
    format.reserve(32); // Default size in Inferno.

    // Loop over the entire format string
    while (i < fmt_len)
    {
        if (b_curr >= b_end)
            return -1;

        auto c = msg_fmt.get_rune(i++);
        if (c != '%')
        {
            b_curr = reinterpret_cast<char *>(utf8::encode(c, reinterpret_cast<uint8_t *>(b_curr)));
            continue;
        }

        format.clear();
        format.push_back('%');
        auto wb = int{ 0 };
        auto big_flag = false;
        auto unsigned_flag = false;

        // Decode the format specifier
        while (i < fmt_len)
        {
            c = msg_fmt.get_rune(i++);
            switch (c)
            {
                // Format flags
            default:
                format.push_back(static_cast<char>(c));
                continue;
            case 'b': // Print big type (64-bit)
                format.push_back('l');
                format.push_back('l');
                big_flag = true;
                continue;
            case '*': // Placeholder for word argument
            {
                const auto w = *reinterpret_cast<word_t *>(msg_args);
                std::array<char, sizeof("-2147483648")> local_buffer;
                const auto len = std::sprintf(local_buffer.data(), "%d", w);
                if (len < 0)
                    return -1;

                format.insert(std::end(format), local_buffer.data(), local_buffer.data() + len);
                msg_args += sizeof(w);
                continue;
            }
            case 'u':
                unsigned_flag = true;
                continue;

                // Format verbs
            case '%': // Escaped specifier
                wb = std::snprintf(b_curr, (b_end - b_curr), "%%%%");
                break;
            case 'f': // floating point verbs
            case 'e':
            case 'E':
            case 'g':
            case 'G':
            {
                format.push_back(static_cast<char>(c));
                format.push_back('\0');

                msg_args = align_for<real_t>(msg_args, base);

                const auto r = *reinterpret_cast<real_t *>(msg_args);
                wb = std::snprintf(b_curr, (b_end - b_curr), format.data(), r);
                msg_args += sizeof(r);
                break;
            }
            case 'd': // decimal
                if (unsigned_flag)
                    c = 'u';
            case 'o': // octal
            case 'x': // hexadecimal
            case 'X': // Upper-case hexadecimal
            case 'c': // Unicode
                format.push_back(static_cast<char>(c));
                format.push_back('\0');
                if (big_flag)
                {
                    msg_args = align_for<big_t>(msg_args, base);

                    const auto b = *reinterpret_cast<big_t *>(msg_args);
                    wb = std::snprintf(b_curr, (b_end - b_curr), format.data(), b);
                    msg_args += sizeof(b);
                }
                else
                {
                    const auto w = *reinterpret_cast<word_t *>(msg_args);
                    wb = std::snprintf(b_curr, (b_end - b_curr), format.data(), w);
                    msg_args += sizeof(w);
                }
                break;
            case 'q':
                assert(false && "'q' format not implemented");
            case 's': // string
            {
                auto p = *reinterpret_cast<pointer_t *>(msg_args);
                auto str = vm_alloc_t::from_allocation<vm_string_t>(p);
                if (str != nullptr)
                    wb = std::snprintf(b_curr, (b_end - b_curr), "%s", str->str());

                msg_args += sizeof(p);
                break;
            }
            case 'r': // Last system error message
            {
                auto err_msg = pop_syscall_error_message(vm);
                wb = std::snprintf(b_curr, (b_end - b_curr), "%s", err_msg.c_str());
                break;
            }
            // [SPEC] Undocumented format verb for debugging VM objects.
            case 'H':
            {
                auto p = *reinterpret_cast<pointer_t *>(msg_args);
                auto alloc = vm_alloc_t::from_allocation(p);
                auto rc = static_cast<std::size_t>(-1);
                const void *type_alloc = nullptr;
                if (alloc != nullptr)
                {
                    rc = alloc->get_ref_count();
                    type_alloc = alloc->alloc_type.get();
                }

                wb = std::snprintf(b_curr, (b_end - b_curr), "%" PRIuPTR ".%#08" PRIxPTR, static_cast<std::uintptr_t>(rc), reinterpret_cast<std::uintptr_t>(type_alloc));
                msg_args += sizeof(p);
                break;
            }
            }

            break;
        }

        if (wb < 0)
            return -1;

        b_curr += wb;
    }

    assert(*b_curr == '\0' && "The buffer should be null-terminated");
    return (b_curr - buffer);
}

word_t disvm::runtime::sys::printf_to_dynamic_buffer(
    disvm::vm_t &vm,
    const disvm::runtime::vm_string_t &msg_fmt,
    disvm::runtime::byte_t *msg_args,
    disvm::runtime::pointer_t base,
    std::vector<char> &buffer)
{
    auto result = word_t{ 0 };
    while (-1 == (result = printf_to_buffer(vm, msg_fmt, msg_args, base, buffer.size(), buffer.data())))
        buffer.resize(buffer.size() * 2);

    return result;
}