#pragma once

#include <string>
#include <vector>
#include <variant>

// Базовый шаблонный класс IPC-сообщения с API add<T>() / get<T>().
// Сериализация вынесена в отдельные сериализаторы (см. IpcSerializer.h).
// Конкретный тип сообщения определяется через type alias в IpcConfig.h.

template<typename Serializer>
class BaseIpcMessage {
public:
    // Тип сырых данных определяется сериализатором
    using RawData = typename Serializer::RawData;
    
    BaseIpcMessage() = default;
    
    // Конструирование из сырых данных (тип определяется сериализатором)
    explicit BaseIpcMessage(const RawData& raw) {
        data_ = Serializer::deserialize(raw);
    }
    
    BaseIpcMessage(const BaseIpcMessage& other)
        : data_(other.data_)
        , pos_(0) {}
    
    BaseIpcMessage& operator=(const BaseIpcMessage& other) {
        if (this != &other) {
            data_ = other.data_;
            pos_ = 0;
        }
        return *this;
    }
    
    // Конструирование исходящего сообщения.
    template<typename T>
    void add(const T& v) {
        data_.emplace_back(v);
    }
    
    // Чтение входящего сообщения по частям.
    template<typename T>
    T get() {
        if (pos_ >= data_.size()) {
            return T{}; // или throw
        }
        
        auto& v = data_[pos_++];
        if constexpr (std::is_same_v<T, int>) {
            if (auto* p = std::get_if<int>(&v)) {
                return *p;
            }
        } else if constexpr (std::is_same_v<T, std::string>) {
            if (auto* p = std::get_if<std::string>(&v)) {
                return *p;
            }
        }
        return T{};
    }
    
    bool empty() const {
        return pos_ >= data_.size();
    }
    
    // Сериализация в сырые данные (тип определяется сериализатором)
    RawData serialize() const {
        return Serializer::serialize(data_);
    }
    
    // Получить сырые данные (для обратной совместимости или отладки)
    RawData raw() const {
        return serialize();
    }
    
private:
    std::vector<std::variant<int, std::string>> data_;
    mutable std::size_t pos_{0};
};