serializable.hxx

#pragma once
 
#include <StormByte/exception.hxx>
#include <StormByte/expected.hxx>
#include <StormByte/helpers.hxx>
#include <StormByte/type_traits.hxx>
 
#include <bit>
#include <cstring>
#include <cstdint>
#include <optional>
#include <span>
#include <utility>
 
namespace StormByte {
    template<typename T>
    class Serializable {
        using DecayedT = std::decay_t<T>;   
        
        public:
            Serializable(const DecayedT& data) noexcept : m_data(data) {}
 
            Serializable(const Serializable& other) noexcept                = delete;
 
            Serializable(Serializable&& other) noexcept                     = delete;
 
            ~Serializable() noexcept                                        = default;
 
            Serializable& operator=(const Serializable& other) noexcept     = delete;
 
            Serializable& operator=(Serializable&& other) noexcept          = delete;
 
            std::vector<std::byte>                                          Serialize() const noexcept {
                if constexpr (std::is_trivially_copyable_v<T>) {
                    return SerializeTrivial();
                } else if constexpr (is_container<T>::value) {
                    return SerializeContainer();
                } else if constexpr (is_pair<T>::value) {
                    return SerializePair();
                } else if constexpr (is_optional<T>::value) {
                    return SerializeOptional();
                } else {
                    return SerializeComplex();
                }
            }
 
            static StormByte::Expected<T, DeserializeError>                 Deserialize(std::span<const std::byte> data) noexcept {
                if constexpr (std::is_trivially_copyable_v<T>) {
                    return DeserializeTrivial(data);
                } else if constexpr (is_container<T>::value) {
                    return DeserializeContainer(data);
                } else if constexpr (is_pair<T>::value) {
                    return DeserializePair(data);
                } else if constexpr (is_optional<T>::value) {
                    return DeserializeOptional(data);
                } else {
                    return DeserializeComplex(data);
                }
            }
 
            static StormByte::Expected<T, DeserializeError>                 Deserialize(const std::vector<std::byte>& data) noexcept {
                return Deserialize(std::span<const std::byte>(data.data(), data.size()));
            }
 
            static std::size_t                                              Size(const DecayedT& data) noexcept {
                if constexpr (std::is_trivially_copyable_v<T>) {
                    return sizeof(data);
                } else if constexpr (is_container<T>::value) {
                    return SizeContainer(data);
                } else if constexpr (is_pair<T>::value) {
                    return SizePair(data);
                } else if constexpr (is_optional<T>::value) {
                    return SizeOptional(data);
                } else {
                    return SizeComplex(data);
                }
            }
 
        private:
            const DecayedT& m_data;                                         
 
            std::vector<std::byte>                                          SerializeTrivial() const noexcept {
                DecayedT value = m_data;
 
                if constexpr (std::endian::native != std::endian::little) {
                    value = swap_endian(value);
                }
 
                return { reinterpret_cast<const std::byte*>(&value), 
                        reinterpret_cast<const std::byte*>(&value) + sizeof(value) };
            }
 
            std::vector<std::byte>                                          SerializeComplex() const noexcept;
 
            std::vector<std::byte>                                          SerializeContainer() const noexcept {
                std::uint64_t size = static_cast<std::uint64_t>(m_data.size());
                Serializable<std::uint64_t> size_serial(size);
                std::vector<std::byte> buffer = size_serial.Serialize();
                buffer.reserve(buffer.size() + SizeContainer(m_data));
                for (const auto& element: m_data) {
                    Serializable<std::decay_t<decltype(element)>> element_serial(element);
                    auto element_data = element_serial.Serialize();
                    append_vector(buffer, std::move(element_data));
                }
                return buffer;
            }
 
            std::vector<std::byte>                                          SerializePair() const noexcept {
                Serializable<std::decay_t<typename T::first_type>> first_serial(m_data.first);
                Serializable<std::decay_t<typename T::second_type>> second_serial(m_data.second);
                std::vector<std::byte> buffer;
                buffer.reserve(SizePair(m_data));
                auto first_data = first_serial.Serialize();
                auto second_data = second_serial.Serialize();
                append_vector(buffer, std::move(first_data));
                append_vector(buffer, std::move(second_data));
                return buffer;
            }
 
            std::vector<std::byte>                                          SerializeOptional() const noexcept {
                bool has_value = m_data.has_value();
                std::vector<std::byte> buffer;
                buffer.reserve(SizeOptional(m_data));
                auto has_value_data = Serializable<bool>(has_value).Serialize();
                append_vector(buffer, std::move(has_value_data));
                if (m_data.has_value()) {
                    Serializable<std::decay_t<decltype(m_data.value())>> value_serial(m_data.value());
                    auto value_data = value_serial.Serialize();
                    append_vector(buffer, std::move(value_data));
                }
                return buffer;
            }
 
            static std::size_t                                              SizeComplex(const DecayedT& data) noexcept;
 
            static std::size_t                                              SizeContainer(const DecayedT& data) noexcept {
                std::size_t size = sizeof(std::uint64_t);
                for (const auto& element: data) {
                    size += Serializable<std::decay_t<decltype(element)>>::Size(element);
                }
                return size;
            }
 
            static std::size_t                                              SizePair(const DecayedT& data) noexcept {
                return
                    Serializable<std::decay_t<typename T::first_type>>::Size(data.first) +
                    Serializable<std::decay_t<typename T::second_type>>::Size(data.second);
            }
 
            static std::size_t                                              SizeOptional(const DecayedT& data) noexcept {
                std::size_t size = sizeof(bool);
                if (data.has_value()) {
                    size += Serializable<std::decay_t<decltype(data.value())>>::Size(data.value());
                }
                return size;
            }
 
            static StormByte::Expected<T, DeserializeError>                 DeserializeTrivial(std::span<const std::byte> data) noexcept {
                if (data.size() < sizeof(T))
                    return StormByte::Unexpected<DeserializeError>("Insufficient data for deserialization");
                T result;
                std::memcpy(&result, data.data(), sizeof(T));
 
                if constexpr (std::endian::native != std::endian::little) {
                    result = swap_endian(result);
                }
 
                return result;
            }
 
            static StormByte::Expected<T, DeserializeError>                 DeserializeTrivial(const std::vector<std::byte>& data) noexcept {
                return DeserializeTrivial(std::span<const std::byte>(data.data(), data.size()));
            }
 
            static StormByte::Expected<T, DeserializeError>                 DeserializeComplex(std::span<const std::byte> data) noexcept;
 
            static StormByte::Expected<T, DeserializeError>                 DeserializeComplex(const std::vector<std::byte>& data) noexcept {
                return DeserializeComplex(std::span<const std::byte>(data.data(), data.size()));
            }
 
            static StormByte::Expected<T, DeserializeError>                 DeserializeContainer(std::span<const std::byte> data) noexcept {
                std::size_t offset = 0;
                
                // Deserialize the container size
                if (offset + sizeof(std::size_t) > data.size())
                    return StormByte::Unexpected<DeserializeError>("Insufficient data for container size");
                
                auto expected_container_size = Serializable<std::size_t>::Deserialize(data.subspan(offset, sizeof(std::size_t)));
                if (!expected_container_size)
                    return StormByte::Unexpected(expected_container_size.error());
                
                std::size_t size = expected_container_size.value();
                offset += sizeof(std::size_t);
 
                // Reject malicious / absurd sizes early
                if (size > data.size() - offset)
                    return StormByte::Unexpected<DeserializeError>("Claimed container size exceeds remaining buffer");
    
                T container;
                for (std::size_t i = 0; i < size; ++i) {
                    using ElementT = std::decay_t<typename T::value_type>;
                    
                    if (offset >= data.size())
                        return StormByte::Unexpected<DeserializeError>("Insufficient data for container element");
                    
                    auto expected_element = Serializable<ElementT>::Deserialize(data.subspan(offset));
                    if (!expected_element)
                        return StormByte::Unexpected(expected_element.error());
 
                    // Calculate the actual size of the deserialized element
                    std::size_t element_size = Serializable<ElementT>::Size(expected_element.value());
                    container.insert(container.end(), std::move(expected_element.value()));
                    offset += element_size;
                }
                return container;
            }
 
            static StormByte::Expected<T, DeserializeError>                 DeserializeContainer(const std::vector<std::byte>& data) noexcept {
                return DeserializeContainer(std::span<const std::byte>(data.data(), data.size()));
            }
 
            static StormByte::Expected<T, DeserializeError>                 DeserializePair(std::span<const std::byte> data) noexcept {
                using FirstT = std::decay_t<typename T::first_type>;
                using SecondT = std::decay_t<typename T::second_type>;
                std::size_t offset = 0;
    
                // Deserialize first element
                auto expected_first = Serializable<FirstT>::Deserialize(data.subspan(offset));
                if (!expected_first)
                    return StormByte::Unexpected(expected_first.error());
                
                offset += Serializable<FirstT>::Size(expected_first.value());
    
                // Deserialize second element
                if (offset >= data.size())
                    return StormByte::Unexpected<DeserializeError>("Insufficient data for pair second element");
                
                auto expected_second = Serializable<SecondT>::Deserialize(data.subspan(offset));
                if (!expected_second)
                    return StormByte::Unexpected(expected_second.error());
    
                return T { std::move(expected_first.value()), std::move(expected_second.value()) };
            }
 
            static StormByte::Expected<T, DeserializeError>                 DeserializePair(const std::vector<std::byte>& data) noexcept {
                return DeserializePair(std::span<const std::byte>(data.data(), data.size()));
            }
 
            static StormByte::Expected<T, DeserializeError>                 DeserializeOptional(std::span<const std::byte> data) noexcept {
                std::size_t offset = 0;
                
                // Deserialize the has_value boolean
                if (offset + sizeof(bool) > data.size())
                    return StormByte::Unexpected<DeserializeError>("Insufficient data for optional flag");
                
                auto expected_has_value = Serializable<bool>::Deserialize(data.subspan(offset, sizeof(bool)));
                if (!expected_has_value)
                    return StormByte::Unexpected(expected_has_value.error());
                
                offset += sizeof(bool);
    
                if (expected_has_value.value()) {
                    if (offset >= data.size())
                        return StormByte::Unexpected<DeserializeError>("Insufficient data for optional value");
                    
                    using ValueT = std::decay_t<typename T::value_type>;
                    auto expected_value = Serializable<ValueT>::Deserialize(data.subspan(offset));
                    if (!expected_value)
                        return StormByte::Unexpected(expected_value.error());
    
                    return T { std::move(expected_value.value()) };
                } else {
                    return T {};
                }
            }
 
            static StormByte::Expected<T, DeserializeError>                 DeserializeOptional(const std::vector<std::byte>& data) noexcept {
                return DeserializeOptional(std::span<const std::byte>(data.data(), data.size()));
            }
    };
}