crunch_detail.hpp

#pragma once
 
#include <crunch/core/crunch_endian.hpp>
#include <crunch/core/crunch_header.hpp>
#include <crunch/integrity/crunch_integrity.hpp>
#include <crunch/messages/crunch_messages.hpp>
#include <crunch/serdes/crunch_serdes.hpp>
#include <crunch/serdes/crunch_static_layout.hpp>
#include <cstddef>
#include <cstring>
#include <span>
#include <variant>
namespace Crunch::detail {
 
template <typename Message, typename Integrity, typename Serdes, std::size_t N>
struct Buffer {
    using MessageType = Message;
    using IntegrityType = Integrity;
    using SerdesType = Serdes;
 
    // cppcheck-suppress unusedStructMember
    static constexpr std::size_t Size = N;
 
    std::array<std::byte, N> data;
    std::size_t used_bytes{0};
 
    [[nodiscard]] constexpr auto span() noexcept {
        return std::span<std::byte, N>{data};
    }
    [[nodiscard]] constexpr auto span() const noexcept {
        return std::span<const std::byte, N>{data};
    }
 
    [[nodiscard]] constexpr auto serialized_message_span() const noexcept {
        return std::span<const std::byte>{data.data(), used_bytes};
    }
};
 
namespace detail {
template <typename T>
struct is_buffer : std::false_type {};
 
template <typename Message, typename Integrity, typename Serdes, std::size_t N>
struct is_buffer<Buffer<Message, Integrity, Serdes, N>> : std::true_type {};
}  // namespace detail
 
template <typename T>
concept IsBuffer = detail::is_buffer<T>::value;
 
template <messages::CrunchMessage Message, typename Integrity, typename Serdes>
    requires IntegrityPolicy<Integrity> && SerdesPolicy<Serdes, Message>
[[nodiscard]] consteval auto GetBufferSize() noexcept -> std::size_t {
    return Serdes::template Size<Message>() + Integrity::size();
}
 
template <typename Message>
    requires messages::CrunchMessage<Message>
[[nodiscard]] constexpr auto Validate(const Message& message) noexcept
    -> std::optional<Error>;
 
template <typename T>
constexpr std::optional<Error> ValidateField(const T& field) {
    if constexpr (requires { field.validate_presence(); }) {
        if (auto err = field.validate_presence(); err) {
            return err;
        }
    }
 
    if constexpr (messages::HasCrunchMessageInterface<typename T::FieldType>) {
        if (const auto* ptr = field.get()) {
            // Recurse into the submessage content
            if (auto err = Validate(*ptr); err) {
                return err;
            }
        }
    } else {
        // Scalar, String, Array
        if (auto err = field.Validate(); err) {
            return err;
        }
    }
    return std::nullopt;
}
 
template <typename Message>
    requires messages::CrunchMessage<Message>
[[nodiscard]] constexpr auto Validate(const Message& message) noexcept
    -> std::optional<Error> {
    std::optional<Error> err;
    std::apply(
        [&](const auto&... fields) {
            ([&] {
                if (err.has_value()) {
                    return false;
                }
                err = ValidateField(fields);
                return !err.has_value();
            }() &&
             ...);
        },
        message.get_fields());
 
    if (err.has_value()) {
        return err;
    }
 
    return message.Validate();
}
 
template <typename Integrity, typename Serdes, messages::CrunchMessage Message,
          std::size_t N>
    requires IntegrityPolicy<Integrity> && SerdesPolicy<Serdes, Message>
 
[[nodiscard]] std::size_t SerializeWithoutValidation(
    std::array<std::byte, N>& buffer, const Message& message) noexcept {
    constexpr std::size_t ChecksumSize = Integrity::size();
    constexpr std::size_t PayloadSize = N - ChecksumSize;
 
    std::span<std::byte, PayloadSize> payload_span(buffer.data(), PayloadSize);
 
    // Write Header
    WriteHeader<Message, Serdes>(payload_span);
 
    // Serialize Payload (Serdes policy executes logic on full span)
    const std::size_t bytes_written = Serdes::Serialize(message, payload_span);
 
    // Calculate and Append Checksum
    if constexpr (ChecksumSize > 0) {
        // Calculate checksum over the header and payload (bytes_written
        // includes both).
        std::span<std::byte> used_payload_span =
            payload_span.subspan(0, bytes_written);
        auto checksum = Integrity::calculate(used_payload_span);
 
        std::span<std::byte, ChecksumSize> checksum_span(
            buffer.data() + bytes_written, ChecksumSize);
        std::copy(checksum.begin(), checksum.end(), checksum_span.begin());
    }
    return bytes_written + ChecksumSize;
}
 
template <typename Integrity, typename Serdes, messages::CrunchMessage Message,
          std::size_t N>
    requires IntegrityPolicy<Integrity> && SerdesPolicy<Serdes, Message>
[[nodiscard]] auto Serialize(std::array<std::byte, N>& buffer,
                             const Message& message) noexcept
    -> std::expected<std::size_t, Error> {
    // Validate Message
    if (auto err = Validate(message); err.has_value()) {
        return std::unexpected(*err);
    }
    return SerializeWithoutValidation<Integrity, Serdes>(buffer, message);
}
 
template <typename Integrity, typename Serdes, typename Message>
    requires IntegrityPolicy<Integrity> && SerdesPolicy<Serdes, Message> &&
             messages::CrunchMessage<Message>
[[nodiscard]] auto Deserialize(std::span<const std::byte> buffer,
                               Message& message) noexcept
    -> std::optional<Error> {
    constexpr std::size_t ChecksumSize = Integrity::size();
 
    if (buffer.size() < ChecksumSize) {
        return Error::deserialization("buffer too small for checksum");
    }
    const std::size_t PayloadSize = buffer.size() - ChecksumSize;
 
    std::span<const std::byte> payload_span = buffer.subspan(0, PayloadSize);
 
    // Execute Integrity Check per policy
    if constexpr (ChecksumSize > 0) {
        const auto expected_checksum = Integrity::calculate(payload_span);
        std::span<const std::byte, ChecksumSize> actual_checksum_span(
            buffer.data() + PayloadSize, ChecksumSize);
 
        // Simple comparison
        const bool match =
            std::equal(expected_checksum.begin(), expected_checksum.end(),
                       actual_checksum_span.begin());
        if (!match) {
            return Error::integrity();
        }
    }
 
    // Validate Header (Version, Format, MessageId)
    auto header_result = ValidateHeader<Message, Serdes>(payload_span);
    if (!header_result) {
        return header_result.error();
    }
 
    // Deserialize (Serdes policy executes its logic on the full span)
    if (const auto err = Serdes::Deserialize(payload_span, message);
        err.has_value()) {
        return err;
    }
 
    // Validate deserialized message
    if (auto err = Validate(message); err.has_value()) {
        return err;
    }
 
    return std::nullopt;
}
 
template <MessageId Id, typename... Messages>
consteval std::size_t CountMessageId() {
    return ((Messages::message_id == Id ? 1 : 0) + ...);
}
 
template <typename... Messages>
consteval bool HasDuplicateMessageIds() {
    return ((CountMessageId<Messages::message_id, Messages...>() > 1) || ...);
}
 
template <typename... Messages>
concept UniqueMessageIds = !HasDuplicateMessageIds<Messages...>();
 
template <typename Serdes, typename Integrity,
          messages::CrunchMessage... Messages>
    requires UniqueMessageIds<Messages...>
class Decoder {
   public:
    using VariantType = std::variant<Messages...>;
 
    [[nodiscard]] constexpr std::optional<Error> Decode(
        std::span<const std::byte> buffer, VariantType& out_message) {
        // Validate Header
        const auto header = GetHeader(buffer);
        if (!header) {
            return header.error();
        }
 
        // Find message which matches header's message_id and deserialize
        std::optional<Error> result = Error::invalid_message_id();
        ([&]() -> bool {
            if (Messages::message_id == header->message_id) {
                Messages msg{};
                auto err = Deserialize<Integrity, Serdes>(buffer, msg);
                if (err) {
                    result = err;
                } else {
                    out_message = std::move(msg);
                    result = std::nullopt;
                }
                return true;
            }
            return false;
        }() || ...);
 
        return result;
    }
 
   private:
    std::variant<
        // Variant holding all possible buffer configurations for the given
        // message types, integrity, and serdes
        Buffer<Messages, Integrity, Serdes,
               GetBufferSize<Messages, Integrity, Serdes>()>...>
        buffer;
};
 
}  // namespace Crunch::detail