#include <xrpl/nodestore/detail/codec.h>

#include <xrpl/nodestore/NodeObject.h>
#include <xrpl/protocol/HashPrefix.h>

#include <gtest/gtest.h>
#include <nudb/detail/buffer.hpp>
#include <nudb/detail/stream.hpp>

#include <array>
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <utility>
#include <vector>

using namespace xrpl;
using namespace xrpl::node_store;

namespace {

// v1 inner-node layout: 16 hashes of 32 bytes each
constexpr std::size_t kHashCount = 16;
constexpr std::size_t kHashSize = 32;

std::vector<std::uint8_t>
makeInnerNode(std::size_t nonEmptySlots)
{
    using namespace nudb::detail;

    static constexpr std::size_t kInnerNodeSize = 525;

    std::array<std::uint8_t, kHashCount * kHashSize> hashes{};
    for (auto slot = 0uz; slot < nonEmptySlots; ++slot)
    {
        for (auto byte = 0uz; byte < kHashSize; ++byte)
        {
            std::size_t const offset = (slot * kHashSize) + byte;
            hashes[offset] = static_cast<std::uint8_t>((offset % 255) + 1);
        }
    }

    std::vector<std::uint8_t> blob(kInnerNodeSize);
    ostream os(blob.data(), blob.size());
    write<std::uint32_t>(os, 0);  // index
    write<std::uint32_t>(os, 0);  // unused
    write<std::uint8_t>(os, static_cast<std::uint8_t>(NodeObjectType::Unknown));
    write<std::uint32_t>(os, static_cast<std::uint32_t>(HashPrefix::InnerNode));
    write(os, hashes.data(), hashes.size());

    return blob;
}

std::uint8_t
codecType(std::pair<void const*, std::size_t> const& compressed)
{
    return static_cast<std::uint8_t const*>(compressed.first)[0];
}

}  // namespace

// All 16 hash slots populated - "full v1 inner node"
TEST(Codec, inner_node_full_roundtrip)
{
    static constexpr std::uint8_t kTypeInnerNodeFull = 3;

    auto const blob = makeInnerNode(kHashCount);

    nudb::detail::buffer compressBuf;
    auto const compressed = nodeobjectCompress(blob.data(), blob.size(), compressBuf);

    EXPECT_EQ(codecType(compressed), kTypeInnerNodeFull);
    EXPECT_EQ(compressed.second, sizeVarint(kTypeInnerNodeFull) + (kHashCount * kHashSize));

    nudb::detail::buffer decompressBuf;
    auto const restored = nodeobjectDecompress(compressed.first, compressed.second, decompressBuf);

    EXPECT_EQ(restored.second, blob.size());
    EXPECT_EQ(std::memcmp(restored.first, blob.data(), blob.size()), 0);
}

// Some hash slots empty - "compressed v1 inner node"
TEST(Codec, inner_node_compressed_roundtrip)
{
    static constexpr std::uint8_t kTypeInnerNodeCompressed = 2;
    static constexpr std::size_t kNonEmpty = 5;
    auto const blob = makeInnerNode(kNonEmpty);

    nudb::detail::buffer compressBuf;
    auto const compressed = nodeobjectCompress(blob.data(), blob.size(), compressBuf);

    EXPECT_EQ(codecType(compressed), kTypeInnerNodeCompressed);
    EXPECT_EQ(
        compressed.second,
        sizeVarint(kTypeInnerNodeCompressed) + sizeof(std::uint16_t) + (kNonEmpty * kHashSize));
    EXPECT_LT(compressed.second, blob.size());

    nudb::detail::buffer decompressBuf;
    auto const restored = nodeobjectDecompress(compressed.first, compressed.second, decompressBuf);

    EXPECT_EQ(restored.second, blob.size());
    EXPECT_EQ(std::memcmp(restored.first, blob.data(), blob.size()), 0);
}

// Anything that is not a v1 inner node - lz4 compressed
TEST(Codec, lz4_roundtrip)
{
    // A payload that is deliberately not a v1 inner node (any size other than 525), filled with a
    // short repeating pattern so lz4 actually shrinks it.
    static constexpr std::size_t kNonInnerNodeSize = 1000;
    static constexpr std::size_t kBytePatternPeriod = 7;
    static constexpr std::uint8_t kTypeLz4 = 1;

    std::vector<std::uint8_t> blob(kNonInnerNodeSize);
    for (auto i = 0uz; i < blob.size(); ++i)
        blob[i] = static_cast<std::uint8_t>(i % kBytePatternPeriod);

    nudb::detail::buffer compressBuf;
    auto const compressed = nodeobjectCompress(blob.data(), blob.size(), compressBuf);

    EXPECT_EQ(codecType(compressed), kTypeLz4);

    nudb::detail::buffer decompressBuf;
    auto const restored = nodeobjectDecompress(compressed.first, compressed.second, decompressBuf);

    EXPECT_EQ(restored.second, blob.size());
    EXPECT_EQ(std::memcmp(restored.first, blob.data(), blob.size()), 0);
}

// An uncompressed blob is never produced by the compressor but must still decode: leading varint 0
// followed by the raw payload.
TEST(Codec, uncompressed_passthrough)
{
    static constexpr std::uint8_t kTypeUncompressed = 0;
    static constexpr auto payload = std::to_array<std::uint8_t>({0xde, 0xad, 0xbe, 0xef, 0x2a});

    std::vector<std::uint8_t> blob;
    blob.push_back(kTypeUncompressed);  // leading varint type tag
    blob.insert(blob.end(), payload.begin(), payload.end());

    nudb::detail::buffer decompressBuf;
    auto const restored = nodeobjectDecompress(blob.data(), blob.size(), decompressBuf);

    EXPECT_EQ(restored.second, payload.size());
    EXPECT_EQ(std::memcmp(restored.first, payload.data(), payload.size()), 0);
}