#ifndef FURVM_THING_HPP
#define FURVM_THING_HPP

#include "furlang/arena.hpp"
#include "furlang/utility/hash.hpp"
#include "furvm/exceptions.hpp"
#include "furvm/fwd.hpp"
#include "furvm/types.hpp"

#include <algorithm>
#include <cassert>
#include <cstddef>
#include <cstring>
#include <functional>
#include <iterator>
#include <new>
#include <stdexcept>
#include <type_traits>
#include <unordered_map>
#include <utility>

namespace furvm {

namespace detail {

struct thing_type_hash {
    std::size_t operator()(const thing_type& type) const {
        std::size_t seed = std::hash<decltype(type.type)>{}(type.type);
        switch (type.type) {
        case thing_type::S8:
        case thing_type::S16:
        case thing_type::S32:
        case thing_type::S64:
        case thing_type::U8:
        case thing_type::U16:
        case thing_type::U32:
        case thing_type::U64:
        case thing_type::String: return seed;
        case thing_type::Ptr:
        case thing_type::Ref: return furlang::utility::hash_combine(seed, thing_type_hash{}(*type.value.typeRef));
        case thing_type::Array:
            seed = furlang::utility::hash_combine(seed, thing_type_hash{}(*type.value.array.type));
            seed = furlang::utility::hash_combine(seed,
                std::hash<decltype(type.value.array.size)>{}(type.value.array.size));
            return seed;
        case thing_type::Slice: return furlang::utility::hash_combine(seed, thing_type_hash{}(*type.value.slice.type));
        case thing_type::Count: break;
        }
        throw std::runtime_error("unreachable");
    }
};

} // namespace detail

class thing_type_store {
public:
    thing_type* insert(thing_type& type) {
        if (auto it = m_typeMap.find(type); it != m_typeMap.end()) return m_map[type.id = it->second];
        if (type.id == thing_type::INVALID_ID) type.id = m_counter++;

        thing_type* ptr = m_arena.allocate<thing_type>(type);
        m_map[type.id]  = ptr;
        m_typeMap[type] = type.id;
        return ptr;
    }

    thing_type* insert(const thing_type& type) {
        if (auto it = m_typeMap.find(type); it != m_typeMap.end()) return m_map[it->second];

        thing_type_id id  = m_counter++;
        thing_type*   ptr = m_arena.allocate<thing_type>(type);
        m_map[id]         = ptr;
        m_typeMap[type]   = id;
        return ptr;
    }

    thing_type* at(thing_type_id id) const {
        if (auto it = m_map.find(id); it != m_map.end()) return it->second;
        return nullptr;
    }
private:
    furlang::arena                                                         m_arena;
    std::unordered_map<thing_type_id, thing_type*>                         m_map;
    std::unordered_map<thing_type, thing_type_id, detail::thing_type_hash> m_typeMap;
    thing_type_id                                                          m_counter = 0;
};

template <template <typename> typename Allocator>
class thing final {
    friend class executor;

    template <template <typename> class Other>
    friend class thing;
public:
    using allocator_type = Allocator<std::byte>; /**< Allocator type. */
public:
    struct string {
        std::size_t size;
        u8*         data;

        static bool matches(const thing_type& type) { return type.type == thing_type::String; }
    };

    struct dynamic_array {
        std::size_t size;
        std::byte*  data;

        static bool matches(const thing_type& type) {
            return type.type == thing_type::Array && type.value.array.size == 0;
        }
    };

    struct slice {
        std::size_t length;
        std::byte*  data;

        static bool matches(const thing_type& type) { return type.type == thing_type::Slice; }
    };

    struct header {
        thing_type type;
    };
private:
    template <bool Const>
    class generic_iterator {
        using owner_type = std::conditional_t<Const, const thing, thing>;
        using data_type  = std::byte;
    public:
        using difference_type   = std::ptrdiff_t;
        using value_type        = thing;
        using pointer           = std::conditional_t<Const, const value_type*, value_type*>;
        using reference         = std::conditional_t<Const, const value_type&, value_type&>;
        using iterator_category = std::random_access_iterator_tag;
    public:
        generic_iterator() = default;

        generic_iterator(owner_type* owner, data_type* ptr)
          : m_owner(owner), m_ptr(ptr) {
            fill();
        }
    public:
        reference operator*() { return m_thing; }

        value_type operator*() const {
            thing thing = { m_thing.type() };
            thing.assign(m_thing);
            return thing;
        }

        reference operator[](difference_type n) { return *(*this + n); }

        pointer operator->() { return &m_thing; }

        generic_iterator& operator+=(difference_type n) {
            m_ptr += n * step_size();
            fill();
            return *this;
        }

        generic_iterator& operator-=(difference_type n) {
            m_ptr -= n * step_size();
            fill();
            return *this;
        }

        generic_iterator operator+(difference_type n) const { return { m_owner, m_ptr + (n * step_size()) }; }

        friend generic_iterator operator+(difference_type n, const generic_iterator& it) {
            return { it.m_owner, it.m_ptr + (n * it.step_size()) };
        }

        generic_iterator operator-(difference_type n) const { return { m_owner, m_ptr - (n * step_size()) }; }

        difference_type operator-(const generic_iterator& other) const { return (m_ptr - other.m_ptr) / step_size(); }

        generic_iterator& operator++() {
            m_ptr += step_size();
            fill();
            return *this;
        }

        generic_iterator operator++(int) { return { m_owner, m_ptr + step_size() }; }

        generic_iterator& operator--() {
            m_ptr -= step_size();
            fill();
            return *this;
        }

        generic_iterator operator--(int) { return { m_owner, m_ptr - step_size() }; }

        bool operator==(const generic_iterator& other) const {
            return m_owner == other.m_owner && m_ptr == other.m_ptr;
        }

        bool operator!=(const generic_iterator& other) const {
            return m_owner != other.m_owner || m_ptr != other.m_ptr;
        }

        bool operator<(const generic_iterator& other) const { return other.m_ptr < m_ptr; }
        bool operator>(const generic_iterator& other) const { return other.m_ptr > m_ptr; }
        bool operator<=(const generic_iterator& other) const { return other.m_ptr <= m_ptr; }
        bool operator>=(const generic_iterator& other) const { return other.m_ptr >= m_ptr; }
    private:
        difference_type step_size() const { return thing::compute_size_na(m_owner->inner_type()); }

        void fill() {
            m_thing.m_reference = true;
            m_thing.m_data      = m_ptr;
            m_thing.m_type      = &m_owner->inner_type();
            m_thing.m_size      = compute_size_na(m_owner->inner_type());
        }
    private:
        owner_type* m_owner = nullptr;
        data_type*  m_ptr   = nullptr;
        thing       m_thing;
    };

    using iterator       = generic_iterator<false>;
    using const_iterator = generic_iterator<true>;
public:
    thing(const allocator_type& allocator = {})
      : m_allocator(allocator) {}

    /**
     * @brief Constructs a thing.
     *
     * @param type Thing type.
     * @param allocator Allocator for the thing's data.
     */
    thing(const thing_type& type, const allocator_type& allocator = {})
      : m_size(compute_size_na(type)), m_allocator(allocator) {
        assert(type.type != thing_type::Ref);
        allocate(type);
    }

    /* NOTE: Furvm forbids allocating references on the heap.
     * This limitation is required for the current implementation of references.
     * Essentialy, references are special things that point directly to other thing's data.
     * The distinction between a reference and the owner is stored inside the reference's
     * thing instance, which makes it impossible to represent them on the heap; however,
     * the same does not apply to the executor's stack, nor it should apply to compound
     * types in the future.
     *
     * TODO: Reword the note above.
     */
    template <template <typename> class Other = Allocator>
    static thing make_reference(const thing<Other>& owner, const allocator_type& allocator = {}) {
        thing ref       = { allocator };
        ref.m_reference = true;
        ref.m_data      = owner.m_data;
        ref.m_type      = owner.m_type;
        ref.m_size      = owner.m_size;
        return ref;
    }
    /**
     * @brief Destructs a thing.
     */
    ~thing() { free(); }

    /**
     * @brief Move constructor.
     */
    thing(thing&& other) noexcept
      : m_reference(other.m_reference),
        m_type(other.m_type),
        m_size(other.m_size),
        m_data(other.m_data),
        m_allocator(other.m_allocator) {
        other.m_type = nullptr;
        other.m_data = nullptr;
        other.m_size = 0;
    }

    /**
     * @brief Move constructor.
     */
    thing& operator=(thing&& other) noexcept {
        if (this == &other) return *this;
        free();
        m_reference  = other.m_reference;
        m_type       = other.m_type;
        m_size       = other.m_size;
        m_data       = other.m_data;
        m_allocator  = std::move(other.m_allocator);
        other.m_type = nullptr;
        other.m_data = nullptr;
        other.m_size = 0;
        return *this;
    }

    thing(const thing& other)
      : m_reference(other.m_reference), m_size(other.m_size), m_allocator(other.m_allocator) {
        if (m_reference) {
            m_type = other.m_type;
            m_data = other.m_data;
            return;
        }
        allocate(other.type());
        other.copy(*this);
    }

    thing& operator=(const thing& other) {
        if (this == &other) return *this;

        free();

        m_reference = other.m_reference;
        m_size      = other.m_size;

        if (m_reference) {
            m_type = other.m_type;
            m_data = other.m_data;
            return *this;
        }
        allocate(other.type());
        other.copy(*this);

        return *this;
    }

    template <template <typename> class Other>
    thing(const thing<Other>& other)
      : m_reference(other.m_reference), m_size(other.m_size) {
        if (m_reference) {
            m_type = other.m_type;
            m_data = other.m_data;
            return;
        }
        allocate(other.type());
        other.copy(*this);
    }

    template <template <typename> class Other>
    thing& operator=(const thing<Other>& other) {
        if (this == &other) return *this;

        free();

        m_reference = other.m_reference;
        m_size      = other.m_size;

        if (m_reference) {
            m_type = other.m_type;
            m_data = other.m_data;
            return *this;
        }
        allocate(other.type());
        other.copy(*this);

        return *this;
    }
public:
    /**
     * @brief Returns a clone of the thing.
     *
     * @return A clone of this thing.
     */
    thing clone() const {
        thing res(m_type, m_allocator);
        copy(res);
        return res;
    }
private:
    template <template <typename> class Other>
    void copy(thing<Other>& dst) const {
        switch (m_type->type) {
        case thing_type::S8:
        case thing_type::S16:
        case thing_type::S32:
        case thing_type::S64:
        case thing_type::U8:
        case thing_type::U16:
        case thing_type::U32:
        case thing_type::U64:
        case thing_type::Ptr:
        case thing_type::Slice: std::memcpy(dst.m_data, m_data, m_size); return;
        case thing_type::Array: copy_list(*m_type, dst.m_data, m_data); return;
        case thing_type::Ref: // TODO: Implement arrays of references (I think they're possible).
        case thing_type::Count: break;
        }
        throw std::runtime_error("unreachable");
    }
public:
    /**
     * @brief Returns the thing's type.
     *
     * @return The type.
     */
    constexpr thing_type type() const { return *m_type; }

    /**
     * @brief Checks if the thing is of a specified type.
     *
     * Compares the true type.
     *
     * @param type Type to compare.
     * @return true if the types match.
     */
    constexpr bool is(enum thing_type::type type) const {
        if (type == thing_type::Ref) return m_reference;
        return m_type->type == type;
    }

    constexpr bool is_reference() const { return m_reference; }
public:
    /**
     * @brief Returns a raw data pointer.
     *
     * @return The data pointer.
     */
    std::byte* raw() { return m_data; }

    /**
     * @brief Returns a raw data pointer.
     *
     * @return The data pointer.
     */
    const std::byte* raw() const { return m_data; }
public:
    /**
     * @brief Returns the thing's value.
     *
     * @return The value.
     */
    template <typename T>
    T& get() {
        if (!detail::thing_traits<T>{}(*m_type)) throw bad_thing_access();
        return *std::launder(reinterpret_cast<T*>(m_data));
    }

    /**
     * @brief Returns the thing's value.
     *
     * @return The value.
     */
    template <typename T>
    const T& get() const {
        if (!detail::thing_traits<T>{}(*m_type)) throw bad_thing_access();
        return *std::launder(reinterpret_cast<const T*>(m_data));
    }

    template <typename T>
    void set(T&& newValue) {
        if (!detail::thing_traits<T>{}(*m_type)) throw bad_thing_access();
        *std::launder(reinterpret_cast<T*>(m_data)) = std::forward<T>(newValue);
    }
public:
    /**
     * @brief Returns a sum of two things.
     *
     * @param rhs Thing to sum with this thing (right-hand-side).
     * @return The sum.
     */
    thing add(const thing& rhs) const { return binary_op(rhs, std::plus<>{}); }

    /**
     * @brief Returns a difference of two things.
     *
     * @param rhs Thing to subtract from this thing (right-hand-side).
     * @return The sum.
     */
    thing sub(const thing& rhs) const { return binary_op(rhs, std::minus<>{}); }

    /**
     * @brief Returns a product of two things.
     *
     * @param rhs Thing to multiply with this thing (right-hand-side).
     * @return The product.
     */
    thing mul(const thing& rhs) const { return binary_op(rhs, std::multiplies<>{}); }

    /**
     * @brief Returns a quotient of two things.
     *
     * @param rhs Thing to divide this thing by (right-hand-side).
     * @return The quotient.
     */
    thing div(const thing& rhs) const { return binary_op(rhs, std::divides<>{}); }

    /**
     * @brief Returns a remainder of two things.
     *
     * @param rhs Thing to divide this thing by (right-hand-side).
     * @return The remainder.
     */
    thing mod(const thing& rhs) const { return binary_op(rhs, std::modulus<>{}); }

    /**
     * @brief Compares two things for equality.
     *
     * @param rhs Thing to compare this thing with (right-hand-side).
     * @return A boolean result of the comparison in a thing form.
     */
    thing equals(const thing& rhs) const { return binary_op(rhs, std::equal_to<>{}); }

    /**
     * @brief Compares two things for inequality.
     *
     * @param rhs Thing to compare this thing with (right-hand-side).
     * @return A boolean result of the comparison in a thing form.
     */
    thing not_equals(const thing& rhs) const { return binary_op(rhs, std::not_equal_to<>{}); }

    /**
     * @brief Compares if this thing is less than an another thing.
     *
     * @param rhs The another thing.
     * @return A boolean result of the comparison in a thing form.
     */
    thing less_than(const thing& rhs) const { return binary_op(rhs, std::less<>{}); }

    /**
     * @brief Compares if this thing is greater than an another thing.
     *
     * @param rhs The another thing.
     * @return A boolean result of the comparison in a thing form.
     */
    thing greater_than(const thing& rhs) const { return binary_op(rhs, std::greater<>{}); }

    /**
     * @brief Compares if this thing is less than or equal to an another thing.
     *
     * @param rhs The another thing.
     * @return A boolean result of the comparison in a thing form.
     */
    thing less_equals(const thing& rhs) const { return binary_op(rhs, std::less_equal<>{}); }

    /**
     * @brief Compares if this thing is greater than or equal to an another thing.
     *
     * @param rhs The another thing.
     * @return A boolean result of the comparison in a thing form.
     */
    thing greater_equals(const thing& rhs) const { return binary_op(rhs, std::greater_equal<>{}); }
public:
    /**
     * @brief Returns a largest integer value of the thing.
     *
     * @return The integer value.
     */
    s64 integer() const {
        switch (type().type) {
        case thing_type::S8: return get<s8>();
        case thing_type::S16: return get<s16>();
        case thing_type::S32: return get<s32>();
        case thing_type::S64: return get<s64>();
        case thing_type::U8: return get<u8>();
        case thing_type::U16: return get<u16>();
        case thing_type::U32: return get<u32>();
        case thing_type::U64: return get<u64>();
        default: throw std::runtime_error("unreachable");
        }
    }

    void resize(u64 newSize) {
        switch (type().type) {
        case thing_type::Array: {
            if (type().value.array.size > 0) throw std::runtime_error("cannot resize a static array");

            auto& array = get<dynamic_array>();
            if (newSize < 0 || newSize == array.size) return;
            std::size_t innerSize = compute_size_na(*type().value.array.type);
            std::byte*  newData   = new std::byte[innerSize * newSize];
            std::memcpy(newData, array.data, innerSize * std::min(static_cast<u64>(array.size), newSize));
            array.size = newSize;
            delete[] array.data;
            array.data = newData;
        } break;
        case thing_type::String: {
            auto& string = get<struct string>();
            if (newSize < 0 || newSize == string.size) return;
            u8* newData = new u8[newSize];
            std::memcpy(newData, string.data, std::min(static_cast<u64>(string.size), newSize));
            string.size = newSize;
            delete[] string.data;
            string.data = newData;
        } break;
        default: throw bad_thing_access();
        }
    }

    thing at(u64 index) const {
        thing ref       = { m_allocator };
        ref.m_reference = true;
        ref.m_size      = compute_size_na(*(ref.m_type = &inner_type()));

        switch (type().type) {
        case thing_type::String: {
            auto& string = get<struct string>();
            if (index < 0 || index >= string.size) throw std::out_of_range("index out of range");

            ref.m_data = reinterpret_cast<std::byte*>(string.data + index);
            return ref;
        }
        case thing_type::Array: {
            if (type().value.array.size == 0) {
                auto& array = get<dynamic_array>();
                if (index < 0 || index >= array.size) throw std::out_of_range("index out of range");

                ref.m_data = array.data + (index * ref.m_size);
                return ref;
            }

            if (index < 0 || index >= type().value.array.size) throw std::out_of_range("index out of range");
            ref.m_data = m_data + (index * ref.m_size);
            return ref;
        }
        case thing_type::Slice: {
            const auto& slice = get<struct slice>();
            if (index < 0 || index >= slice.length) throw std::out_of_range("index out of range");
            ref.m_data = slice.data + (index * ref.m_size);
            return ref;
        }
        default: throw bad_thing_access();
        }
    }

    thing slice(u64 begin, u64 len) const {
        auto& inner = inner_type();

        thing_type sliceType;
        sliceType.type             = thing_type::Slice;
        sliceType.value.slice.type = &inner;

        thing slice = { sliceType, m_allocator };
        auto& data  = slice.get<struct slice>();

        if (begin >= length()) throw std::out_of_range("begin index out of range");
        len = std::min(len, length() - begin);

        switch (type().type) {
        case thing_type::String: {
            data.data = reinterpret_cast<std::byte*>(get<struct string>().data);
        } break;
        case thing_type::Array: {
            data.data = ((type().value.array.size != 0) ? m_data : get<dynamic_array>().data);
        } break;
        case thing_type::Slice: {
            data.data = get<struct slice>().data;
        } break;
        default: throw bad_thing_access();
        }

        data.data  += (compute_size_na(inner) * begin);
        data.length = len;
        return slice;
    }

    u64 length() const {
        switch (type().type) {
        case thing_type::String: return get<struct string>().size;
        case thing_type::Array:
            return type().value.array.size == 0 ? get<dynamic_array>().size : type().value.array.size;
        case thing_type::Slice: return get<struct slice>().length;
        default: throw bad_thing_access();
        }
    }

    template <typename T, typename = std::enable_if_t<std::is_integral_v<T>>>
    T cast_to() const {
        return visit_primitive([](auto value) { return static_cast<T>(value); });
    }

    /**
     * @brief Self-explainatory.
     *
     * TODO: Document
     */
    void assign(thing&& thing) {
        class thing rhs = std::move(thing);
        if (type() != rhs.type()) throw std::runtime_error("thing type mismatch");
        // TODO: Move this to another function
        switch (type().type) {
        case thing_type::S8:
        case thing_type::S16:
        case thing_type::S32:
        case thing_type::S64:
        case thing_type::U8:
        case thing_type::U16:
        case thing_type::U32:
        case thing_type::U64: std::memcpy(m_data, rhs.m_data, m_size); return;
        case thing_type::String:
        case thing_type::Ptr:
        case thing_type::Ref:
        case thing_type::Array:
        case thing_type::Slice: throw std::runtime_error("unimplemented");
        case thing_type::Count: break;
        }
        throw std::runtime_error("unreachable");
    }

    void assign(const thing& rhs) {
        if (type() != rhs.type()) throw std::runtime_error("thing type mismatch");
        // TODO: Move this to another function
        switch (type().type) {
        case thing_type::S8:
        case thing_type::S16:
        case thing_type::S32:
        case thing_type::S64:
        case thing_type::U8:
        case thing_type::U16:
        case thing_type::U32:
        case thing_type::U64: std::memcpy(m_data, rhs.m_data, m_size); return;
        case thing_type::Ptr:
        case thing_type::Ref:
        case thing_type::Array:
        case thing_type::Slice: throw std::runtime_error("unimplemented");
        case thing_type::Count: break;
        }
        throw std::runtime_error("unreachable");
    }

    template <typename T>
    void assign(const T& value) {
        if constexpr (detail::cassignable_to_thing<T, thing>::value) {
            detail::thing_traits<T>::assign_to(*this, value);
        } else {
            get<T>() = value;
        }
    }

    template <typename T>
    void assign(T&& value) { // NOLINT
        if constexpr (detail::massignable_to_thing<T, thing>::value) {
            detail::thing_traits<T>::assign_to(*this, std::move(value)); // NOLINT
        } else {
            get<T>() = std::move(value); // NOLINT
        }
    }
public:
    iterator begin() {
        switch (type().type) {
        case thing_type::String: return { this, reinterpret_cast<std::byte*>(get<struct string>().data) };
        case thing_type::Array: return { this, (type().value.array.size == 0) ? get<dynamic_array>().data : m_data };
        case thing_type::Slice: return { this, get<struct slice>().data };
        default: throw bad_thing_access();
        }
    }

    iterator end() { return begin() + length(); }

    const_iterator cbegin() const {
        switch (type().type) {
        case thing_type::String: return { this, reinterpret_cast<std::byte*>(get<struct string>().data) };
        case thing_type::Array: return { this, (type().value.array.size == 0) ? get<dynamic_array>().data : m_data };
        case thing_type::Slice: return { this, get<struct slice>().data };
        default: throw bad_thing_access();
        }
    }

    const_iterator cend() const { return cbegin() + length(); }

    const_iterator begin() const { return cbegin(); }

    const_iterator end() const { return cend(); }
private:
    static void copy_list(const thing_type& arrayType, void* dst, const void* src) {
        if (arrayType.type != thing_type::Array || arrayType.value.array.type == nullptr)
            throw std::runtime_error("invalid type");

        const auto& innerType   = *arrayType.value.array.type;
        std::size_t elementSize = compute_size_na(innerType);

        std::size_t size = 0;
        if (arrayType.value.array.size == 0) {
            const dynamic_array& srcDynArr = *std::launder(reinterpret_cast<const dynamic_array*>(src));
            dynamic_array&       dstDynArr = *std::launder(reinterpret_cast<dynamic_array*>(dst));

            size = dstDynArr.size = srcDynArr.size;
            if (dstDynArr.size < 0) {
                dstDynArr.data = nullptr;
                return;
            }

            src = srcDynArr.data;
            dst = dstDynArr.data = new std::byte[dstDynArr.size * elementSize];
        } else {
            size = arrayType.value.array.size;
        }

        switch (innerType.type) {
        case thing_type::S8:
        case thing_type::S16:
        case thing_type::S32:
        case thing_type::S64:
        case thing_type::U8:
        case thing_type::U16:
        case thing_type::U32:
        case thing_type::U64:
        case thing_type::String:
        case thing_type::Ptr:
        case thing_type::Ref:
        case thing_type::Slice: std::memcpy(dst, src, size * elementSize); return;
        case thing_type::Array:
            for (std::size_t i = 0; i < size; ++i) {
                copy_list(*innerType.value.array.type,
                    reinterpret_cast<std::byte*>(dst) + (i * elementSize),
                    reinterpret_cast<const std::byte*>(src) + (i * elementSize));
            }
            return;
        case thing_type::Count: break;
        }
        throw std::runtime_error("unreachable");
    }
private:
    static std::size_t compute_size_na(const thing_type& type) {
        switch (type.type) {
        case thing_type::S8: return sizeof(s8);
        case thing_type::S16: return sizeof(s16);
        case thing_type::S32: return sizeof(s32);
        case thing_type::S64: return sizeof(s64);
        case thing_type::U8: return sizeof(u8);
        case thing_type::U16: return sizeof(u16);
        case thing_type::U32: return sizeof(u32);
        case thing_type::U64: return sizeof(u64);
        case thing_type::String: return sizeof(string);
        case thing_type::Ptr: return sizeof(void*);
        case thing_type::Array:
            return type.value.array.size == 0 ? sizeof(dynamic_array)
                                              : compute_size_na(*type.value.array.type) * type.value.array.size;
        case thing_type::Slice: return sizeof(struct slice);
        case thing_type::Ref:
        case thing_type::Count: break;
        }

        throw std::runtime_error("unreachable");
    }

    // NOTE: Align to 4 bytes
    static std::size_t compute_size(const thing_type& type) { return (compute_size_na(type) + 3) & ~3; }
private:
    template <typename Func>
    decltype(auto) visit_primitive(Func&& func) const {
        switch (type().type) {
        case thing_type::S8: return std::forward<Func>(func)(get<s8>());
        case thing_type::S16: return std::forward<Func>(func)(get<s16>());
        case thing_type::S32: return std::forward<Func>(func)(get<s32>());
        case thing_type::S64: return std::forward<Func>(func)(get<s64>());
        case thing_type::U8: return std::forward<Func>(func)(get<u8>());
        case thing_type::U16: return std::forward<Func>(func)(get<u16>());
        case thing_type::U32: return std::forward<Func>(func)(get<u32>());
        case thing_type::U64: return std::forward<Func>(func)(get<u64>());
        default: throw bad_thing_access();
        }
    }

    template <typename Op>
    thing binary_op(const thing& rhs, const Op& op) const {
        if (thing_type::is_primitive(type().type) && thing_type::is_primitive(type().type)) {
            static constexpr enum thing_type::type promotions[8 * 8] = {
                // S8
                thing_type::S8,
                thing_type::S16,
                thing_type::S32,
                thing_type::S64,
                thing_type::S16,
                thing_type::S16,
                thing_type::S32,
                thing_type::U64,
                // S16
                thing_type::S16,
                thing_type::S16,
                thing_type::S32,
                thing_type::S64,
                thing_type::S16,
                thing_type::S16,
                thing_type::S32,
                thing_type::U64,
                // S32
                thing_type::S32,
                thing_type::S32,
                thing_type::S32,
                thing_type::S64,
                thing_type::S32,
                thing_type::S32,
                thing_type::U32,
                thing_type::U64,
                // S64
                thing_type::S64,
                thing_type::S64,
                thing_type::S64,
                thing_type::S64,
                thing_type::S64,
                thing_type::S64,
                thing_type::S64,
                thing_type::U64,
                // U8
                thing_type::S16,
                thing_type::S16,
                thing_type::S32,
                thing_type::S64,
                thing_type::U8,
                thing_type::U16,
                thing_type::U32,
                thing_type::U64,
                // U16
                thing_type::S16,
                thing_type::S16,
                thing_type::S32,
                thing_type::S64,
                thing_type::U16,
                thing_type::U16,
                thing_type::U32,
                thing_type::U64,
                // U32
                thing_type::S32,
                thing_type::S32,
                thing_type::U32,
                thing_type::S64,
                thing_type::U32,
                thing_type::U32,
                thing_type::U32,
                thing_type::U64,
                // U64
                thing_type::U64,
                thing_type::U64,
                thing_type::U64,
                thing_type::U64,
                thing_type::U64,
                thing_type::U64,
                thing_type::U64,
                thing_type::U64,
            };

            enum thing_type::type resultType = promotions[type().type + (rhs.type().type * 8)];

            thing res = { thing_type{ resultType }, m_allocator };
            switch (resultType) {
            case thing_type::S8: res.get<s8>() = Op{}(cast_to<s8>(), rhs.cast_to<s8>()); return res;
            case thing_type::S16: res.get<s16>() = Op{}(cast_to<s16>(), rhs.cast_to<s16>()); return res;
            case thing_type::S32: res.get<s32>() = Op{}(cast_to<s32>(), rhs.cast_to<s32>()); return res;
            case thing_type::S64: res.get<s64>() = Op{}(cast_to<s64>(), rhs.cast_to<s64>()); return res;
            case thing_type::U8: res.get<u8>() = Op{}(cast_to<u8>(), rhs.cast_to<u8>()); return res;
            case thing_type::U16: res.get<u16>() = Op{}(cast_to<u16>(), rhs.cast_to<u16>()); return res;
            case thing_type::U32: res.get<u32>() = Op{}(cast_to<u32>(), rhs.cast_to<u32>()); return res;
            case thing_type::U64: res.get<u64>() = Op{}(cast_to<u64>(), rhs.cast_to<u64>()); return res;
            case thing_type::String:
            case thing_type::Ptr: // TODO: Pointer arithmetics
            case thing_type::Ref:
            case thing_type::Array:
            case thing_type::Slice:
            case thing_type::Count: break;
            }
            throw std::runtime_error("unreachable");
        }

        throw std::runtime_error("unexpected operation");
    }
private:
    void allocate(const thing_type& type) {
        m_data = m_allocator.allocate(sizeof(header) + compute_size(type));

        header* hdr = reinterpret_cast<header*>(m_data);
        hdr->type   = type;
        m_type      = &hdr->type;

        m_data += sizeof(header);
        std::memset(m_data, 0, m_size);
    }

    void free() {
        if (!m_reference && m_data != nullptr) m_allocator.deallocate(m_data - sizeof(header), m_size + sizeof(header));
        m_data = nullptr;
        m_type = nullptr;
    }

    thing_type& inner_type() const {
        switch (type().type) {
        case thing_type::String: {
            static thing_type s_inner = { thing_type::U8 };
            return s_inner;
        }
        case thing_type::Array: return *type().value.array.type;
        case thing_type::Slice: return *type().value.slice.type;
        default: throw bad_thing_access();
        }
    }
private:
    // A flag indicating whether the thing instance owns the data, or not.
    bool m_reference = false;

    const thing_type* m_type = nullptr;
    std::size_t       m_size = 0;
    std::byte*        m_data = nullptr;

    allocator_type m_allocator;
};

namespace detail {

template <>
struct thing_traits<std::string_view> {
    template <template <typename...> class Allocator>
    static void assign_to(thing<Allocator>& thing, const std::string_view& value) {
        using Thing = furvm::thing<Allocator>;

        auto& string = thing.template get<typename Thing::string>();
        string.data  = new furvm::u8[string.size = value.length()];
        std::memcpy(string.data, value.data(), value.length());
    }
};

template <>
struct thing_traits<std::string> {
    template <template <typename...> class Allocator>
    static void assign_to(thing<Allocator>& thing, const std::string& value) {
        using Thing = furvm::thing<Allocator>;

        auto& string = thing.template get<typename Thing::string>();
        string.data  = new furvm::u8[string.size = value.length()];
        std::memcpy(string.data, value.data(), value.length());
    }
};

} // namespace detail

} // namespace furvm

#endif // FURVM_THING_HPP