path: root/src/MultigroupCodec.cpp

#include "MultigroupCodec.h"

#include "Merkle.h"

#include <map>

namespace nt::MultigroupCodec
{
    // A relation with zero tuples reports an empty merkle_root externally.
    // The merkle tree's payload type is fixed-width Hash32, so the codec
    // maps "" ↔ the all-zero hash. The collision probability with a real
    // SHA256 hitting all-zero (2^-256) is treated as unreachable.
    static nt::Hash32 encode_payload(const std::string& hex)
    {
        if (hex.empty()) return nt::Hash32{};
        return nt::hex_to_bin(hex);
    }

    static std::string decode_payload(const nt::Hash32& bin)
    {
        static const nt::Hash32 zero{};
        if (bin == zero) return "";
        return nt::bin_to_hex(bin);
    }

    std::string Build(IStorageBackend& store,
                      const std::vector<RelationEntry>& relations)
    {
        std::map<std::string, std::string> canonical;
        for (const auto& [name, root_hex] : relations)
            canonical[name] = root_hex;

        std::string root;
        for (const auto& [name, root_hex] : canonical)
            root = nt::Merkle<std::string>::Insert(store, root, name,
                                                    encode_payload(root_hex));
        return root;
    }

    std::vector<RelationEntry> List(IStorageBackend& store,
                                     const std::string& root_hex)
    {
        std::vector<RelationEntry> out;
        constexpr size_t kPageSize = 1024;
        size_t offset = 0;
        while (true)
        {
            auto page = nt::Merkle<std::string>::Page(store, root_hex,
                                                      offset, kPageSize);
            if (page.empty()) break;
            for (auto& entry : page)
                out.emplace_back(std::move(entry.key),
                                  decode_payload(entry.payload));
            if (page.size() < kPageSize) break;
            offset += page.size();
        }
        return out;
    }

    std::string InsertOne(IStorageBackend& store,
                          const std::string& root_hex,
                          const std::string& relation_name,
                          const std::string& relation_root_hex)
    {
        return nt::Merkle<std::string>::Insert(store, root_hex, relation_name,
                                                encode_payload(relation_root_hex));
    }

    std::string RemoveOne(IStorageBackend& store,
                          const std::string& root_hex,
                          const std::string& relation_name)
    {
        return nt::Merkle<std::string>::Remove(store, root_hex, relation_name);
    }

    std::string Lookup(IStorageBackend& store,
                       const std::string& root_hex,
                       const std::string& relation_name)
    {
        auto found = nt::Merkle<std::string>::Get(store, root_hex, relation_name);
        if (!found) return "";
        return decode_payload(*found);
    }
}