//-----------------------------------------------------------------------------
//     ___                      __ _       _
//    / _ \__ _ _ __ ___  ___  / /(_)_ __ | | __
//   / /_)/ _` | '__/ __|/ _ \/ / | | '_ \| |/ /
//  / ___/ (_| | |  \__ \  __/ /__| | | | |   <
//  \/    \__,_|_|  |___/\___\____/_|_| |_|_|\_\ .
//
//-----------------------------------------------------------------------------
// Author: Kurt Sassenrath
// Module: msgpack
//
// Default packer tests.
//
// Copyright (c) 2023 Kurt Sassenrath.
//
// License TBD.
//-----------------------------------------------------------------------------

#include "parselink/msgpack/core/packer.h"

#include <fmt/format.h>
#include <fmt/ranges.h>

#include "rng.h"
#include <boost/ut.hpp>
#include <chrono>

using namespace boost::ut;

namespace {

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

constexpr auto equal(auto a, auto b) {
    return std::equal(std::begin(a), std::end(a), std::begin(b), std::end(b));
}

template <typename T>
struct test_data {};

template <>
struct test_data<std::uint64_t> {
    static constexpr auto values = std::to_array<std::uint64_t>({
            0x00,              // positive fixint
            0x79,              // positive fixint
            0x80,              // uint8
            0xff,              // uint8
            0x100,             // uint16
            0xffff,            // uint16
            0x10000,           // uint32
            0xffffffff,        // uint32
            0x100000000,       // uint64
            0xffffffffffffffff // uint64
    });

    static constexpr auto payload = make_bytes(0x00, // positive fixint
            0x79,                                    // positive fixint
            0xcc, 0x80,                              // uint8
            0xcc, 0xff,                              // uint8
            0xcd, 0x01, 0x00,                        // uint16
            0xcd, 0xff, 0xff,                        // uint16
            0xce, 0x00, 0x01, 0x00, 0x00,            // uint32
            0xce, 0xff, 0xff, 0xff, 0xff,            // uint32
            0xcf, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, // uint64
            0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff  // uint64
    );

    static constexpr auto valid(auto value) noexcept {
        return value <= std::numeric_limits<std::uint64_t>::max();
    }
};

template <std::unsigned_integral T>
struct test_data<T> : test_data<std::uint64_t> {
    static constexpr auto valid(auto value) noexcept {
        return value <= std::numeric_limits<T>::max();
    }
};

template <>
struct test_data<std::int64_t> {
    static constexpr auto values = std::to_array<std::int64_t>({
            -1,                                          // negative fixint
            -32,                                         // negative fixint
            -33,                                         // int8
            -128,                                        // int8
            0,                                           // int8
            127,                                         // int8
            128,                                         // int16
            -129,                                        // int16
            -32768,                                      // int16
            32767,                                       // int16
            -32769,                                      // int32
            32768,                                       // int32
            -2147483648,                                 // int32
            2147483647,                                  // int32
            -2147483649,                                 // int64
            2147483648,                                  // int64
            std::numeric_limits<std::int64_t>::lowest(), // int64
            std::numeric_limits<std::int64_t>::max(),    // int64
    });

    static constexpr auto payload = make_bytes(0xff, // negative fixint
            0xe0,                                    // negative fixint
            0xd0, 0xdf,                              // int8
            0xd0, 0x80,                              // int8
            0xd0, 0x0,                               // int8
            0xd0, 0x7f,                              // int8
            0xd1, 0x00, 0x80,                        // int16
            0xd1, 0xff, 0x7f,                        // int16
            0xd1, 0x80, 0x00,                        // int16
            0xd1, 0x7f, 0xff,                        // int16
            0xd2, 0xff, 0xff, 0x7f, 0xff,            // int32
            0xd2, 0x00, 0x00, 0x80, 0x00,            // int32
            0xd2, 0x80, 0x00, 0x00, 0x00,            // int32
            0xd2, 0x7f, 0xff, 0xff, 0xff,            // int32
            0xd3, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, // int64
            0xd3, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, // int64
            0xd3, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // int64
            0xd3, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff  // int64
    );

    static constexpr auto valid(auto value) noexcept {
        return value <= std::numeric_limits<std::int64_t>::max()
            && value >= std::numeric_limits<std::int64_t>::lowest();
    }
};

template <std::convertible_to<std::string_view> T>
struct test_data<T> {
    static constexpr auto values = std::to_array<T>({
            "",                                 // fixstr
            "0",                                // fixstr
            "0123456789abcdef0123456789abcde",  // fixstr
            "0123456789abcdef0123456789abcdef", // str8
    });

    static constexpr auto payload = make_bytes(0xa0, // fixstr
            0xa1, 0x30,                              // fixstr

            // fixstr
            0xbf, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
            0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x30, 0x31, 0x32, 0x33, 0x34,
            0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65,

            // str8
            0xd9, 0x20, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
            0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x30, 0x31, 0x32, 0x33,
            0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65,
            0x66);

    static constexpr auto valid(T value) noexcept {
        return std::string_view(value).size()
            <= std::numeric_limits<std::uint32_t>::max();
    }
};

template <>
struct test_data<std::span<std::byte const>> {
    static constexpr auto test1 = make_bytes(0x02, 0x03);
    static constexpr auto values =
            std::to_array<std::span<std::byte const>>({test1});
    static constexpr auto payload = make_bytes(0xc4, 0x02, 0x02, 0x03);

    static constexpr auto valid(auto value) noexcept {
        return value.size() <= std::numeric_limits<std::uint32_t>::max();
    }
};

template <std::signed_integral T>
struct test_data<T> : test_data<std::int64_t> {
    static constexpr auto valid(auto value) noexcept {
        return value <= std::numeric_limits<T>::max()
            && value >= std::numeric_limits<T>::lowest();
    }
};

template <typename T>
bool test_deduced() noexcept {
    constexpr auto const& expected_payload = test_data<T>::payload;
    std::array<std::byte, expected_payload.size()> payload;

    msgpack::packer packer(payload);
    for (auto const& value : test_data<T>::values) {
        if (!test_data<T>::valid(value)) break;
        expect(!!packer.pack(T(value)));
        auto expect = std::span(expected_payload.begin(), packer.tell());
        auto correct = equal(packer.subspan(), expect);
        if (!correct) {
            fmt::print("Deduction failed for '{}'\n", T(value));
            fmt::print("\tActual: {::#04x}\n", packer.subspan());
            fmt::print("\tExpect: {::#04x}\n", expect);
            return false;
        }
    }
    return true;
}

} // anonymous namespace

suite packer = [] {
    "packer::pack<std::uint8_t>"_test = [] {
        expect(test_deduced<std::uint8_t>());
    };
    "packer::pack<std::uint16_t>"_test = [] {
        expect(test_deduced<std::uint16_t>());
    };
    "packer::pack<std::uint32_t>"_test = [] {
        expect(test_deduced<std::uint32_t>());
    };
    "packer::pack<std::uint64_t>"_test = [] {
        expect(test_deduced<std::uint64_t>());
    };

    "packer::pack<std::int8_t>"_test = [] {
        expect(test_deduced<std::int8_t>());
    };
    "packer::pack<std::int16_t>"_test = [] {
        expect(test_deduced<std::int16_t>());
    };
    "packer::pack<std::int32_t>"_test = [] {
        expect(test_deduced<std::int32_t>());
    };
    "packer::pack<std::int64_t>"_test = [] {
        expect(test_deduced<std::int64_t>());
    };

    "packer::pack<std::string_view>"_test = [] {
        expect(test_deduced<std::string_view>());
    };
    "packer::pack<char const*>"_test = [] {
        expect(test_deduced<char const*>());
    };
    "packer::pack<std::array<std::byte>>"_test = [] {
        expect(test_deduced<std::span<std::byte const>>());
    };
};

static constexpr auto num_bytes(std::uint64_t count) {
    if (count <= 0x7f) return 0;
    if (count < 0x100) return 1;
    if (count < 0x10000) return 2;
    if (count < 0x100000000) return 4;
    return 8;
}

static constexpr std::size_t bit_count_bytes(std::uint64_t count) {
    if (count <= 0x7f) return 0;
    return std::bit_ceil(std::uint64_t((std::bit_width(count) + 7) >> 3));
}

suite perf = [] {
    "test"_test = [] {
        for (auto j = 0; j < 10; ++j) {
            using namespace std::chrono_literals;
            std::vector<std::uint64_t> a;
            std::vector<std::uint64_t> r1;
            std::vector<std::uint64_t> r2;
            a.reserve(10000000);
            r1.reserve(10000000);
            r2.reserve(10000000);
            rng x;

            for (auto i = 0; i < 10000000; ++i) {
                a.push_back(x.get<std::size_t>());
            }

            auto start2 = std::chrono::steady_clock::now();
            for (auto v : a) {
                r2.push_back(num_bytes(v));
            }
            auto end2 = std::chrono::steady_clock::now();

            auto start = std::chrono::steady_clock::now();
            for (auto v : a) {
                r1.push_back(bit_count_bytes(v));
            }
            auto end = std::chrono::steady_clock::now();

            fmt::print("Time taken: {}us vs {}us\n", (end - start) / 1us,
                    (end2 - start2) / 1us);
        }
    };
};