//
// Created by Kirill Zhukov on 20.04.2025.
//

#include "Command.h"

#include <istream>
#include <ostream>

namespace usub::core
{
    Command::Command()
    {
        ready.store(0, std::memory_order_relaxed);
        response_ready.store(0, std::memory_order_relaxed);
        op = OperationType::PUT;
        key = utils::Hash128{};
        value_size = 0;
        response_size = 0;
    }

    Command::Command(const Command& other)
    {
        ready.store(other.ready.load(std::memory_order_relaxed), std::memory_order_relaxed);
        op = other.op;
        key = other.key;
        value_size = other.value_size;
        std::memcpy(value, other.value, other.value_size);

        response_ready.store(other.response_ready.load(std::memory_order_relaxed), std::memory_order_relaxed);
        response_size = other.response_size;
        std::memcpy(response, other.response, other.response_size);
    }

    Command& Command::operator=(const Command& other)
    {
        if (this != &other)
        {
            ready.store(other.ready.load(std::memory_order_relaxed), std::memory_order_relaxed);
            op = other.op;
            key = other.key;
            value_size = other.value_size;
            std::memcpy(value, other.value, other.value_size);

            response_ready.store(other.response_ready.load(std::memory_order_relaxed), std::memory_order_relaxed);
            response_size = other.response_size;
            std::memcpy(response, other.response, other.response_size);
        }
        return *this;
    }

    void Command::serialize(std::ostream& out) const
    {
        auto op_val = static_cast<uint8_t>(op);
        out.write(reinterpret_cast<const char*>(&op_val), sizeof(op_val));
        out.write(reinterpret_cast<const char*>(&key), sizeof(key));

        if (op == OperationType::PUT)
        {
            out.write(reinterpret_cast<const char*>(&value_size), sizeof(value_size));
            out.write(value, value_size);
        }
    }

    Command Command::deserialize(std::istream& in)
    {
        uint8_t op_val;
        in.read(reinterpret_cast<char*>(&op_val), sizeof(op_val));

        Command cmd;
        cmd.op = static_cast<OperationType>(op_val);

        in.read(reinterpret_cast<char*>(&cmd.key), sizeof(cmd.key));

        if (cmd.op == OperationType::PUT)
        {
            in.read(reinterpret_cast<char*>(&cmd.value_size), sizeof(cmd.value_size));
            in.read(cmd.value, cmd.value_size);
        }

        return cmd;
    }
}