#ifndef msgpack_test_utils_4573e6627d8efe78
#define msgpack_test_utils_4573e6627d8efe78

#include <boost/ut.hpp>
#include <magic_enum.hpp>

#include <fmt/format.h>

template <typename T>
constexpr bool operator==(std::span<T const> a, std::span<T const> b) noexcept {
    return std::equal(a.begin(), a.end(), b.begin(), b.end());
}

template <typename T>
constexpr std::array<std::byte, sizeof(T)> as_bytes(T&& t) {
    return std::bit_cast<std::array<std::byte, sizeof(T)>>(std::forward<T>(t));
}

template <typename... Bytes>
constexpr std::array<std::byte, sizeof...(Bytes)> make_bytes(Bytes&&... bytes) {
    return {std::byte(std::forward<Bytes>(bytes))...};
}

template <typename T, std::size_t C = 1024 * 1024>
struct oversized_array {
    std::array<T, C> data;
    std::size_t size;
};

constexpr auto to_bytes_array_oversized(auto const& container) {
    using value_type = std::decay_t<decltype(container[0])>;
    oversized_array<value_type> arr;
    std::copy(std::begin(container), std::end(container), std::begin(arr.data));
    arr.size = std::distance(std::begin(container), std::end(container));
    return arr;
}

consteval auto generate_bytes(auto callable) {
    constexpr auto oversized = to_bytes_array_oversized(callable());
    using value_type = std::decay_t<decltype(oversized.data[0])>;
    std::array<value_type, oversized.size> out;
    std::copy(std::begin(oversized.data),
            std::next(std::begin(oversized.data), oversized.size),
            std::begin(out));
    return out;
}

consteval auto build_string(auto callable) {
    constexpr auto string_array = generate_bytes(callable);
    return string_array;
}

template <std::size_t... Sizes>
constexpr auto cat(std::array<std::byte, Sizes> const&... a) noexcept {
    std::array<std::byte, (Sizes + ...)> out;
    std::size_t index{};
    ((std::copy_n(a.begin(), Sizes, out.begin() + index), index += Sizes), ...);
    return out;
}

constexpr auto repeat(std::span<std::byte const> sv, std::size_t count) {
    std::vector<std::byte> range;
    range.reserve(sv.size() * count);
    for (decltype(count) i = 0; i < count; ++i) {
        std::copy_n(sv.begin(), sv.size(), std::back_inserter(range));
    }
    return range;
}

constexpr auto repeat(std::string_view sv, std::size_t count) {
    std::vector<char> range;
    range.reserve(sv.size() * count);
    for (decltype(count) i = 0; i < count; ++i) {
        std::copy_n(sv.begin(), sv.size(), std::back_inserter(range));
    }
    return range;
}

constexpr auto from_string_view(std::string_view sv) {
    std::vector<std::byte> range;
    range.resize(sv.size());
    auto itr = range.begin();
    for (auto c : sv) {
        *itr = std::byte(c);
        ++itr;
    }
    return range;
}

template <typename T, typename E>
std::ostream& operator<<(std::ostream& os, tl::expected<T, E> const& exp) {
    if (exp.has_value()) {
        os << "Value: '" << *exp << "'";
    } else {
        os << "Error";
    }
    return os;
}

#endif // msgpack_test_utils_4573e6627d8efe78