client_message.h

/*
// client_message.h
// Covers:
//     - split_slash() helper for splitting the message string into parts
//     - parse_uint64() helper for parsing integers with error checking
//     - build_message() function to parse the -m string and emit a binary datagram
*/

#ifndef CLIENT_MESSAGE_H
#define CLIENT_MESSAGE_H

#include "protocol.h"
#include "helpers.h"

#include <arpa/inet.h>
#include <cerrno>
#include <cstdlib>
#include <cstring>

#include <string>
#include <vector>

/// Splits s by '/' and returns the resulting parts.
static std::vector<std::string> split_slash(const std::string &s) {
    std::vector<std::string> parts;
    std::string cur;
    for (char c : s) {
        if (c == '/') {
            parts.push_back(cur);
            cur.clear();
        } else {
            cur += c;
        }
    }
    parts.push_back(cur);
    return parts;
}

/// Parses a non-negative decimal integer from s into out.
/// Returns false if parsing fails or the value exceeds max_val.
static bool parse_uint64(const std::string &s, uint64_t max_val, uint64_t &out) {
    if (s.empty()) return false;
    char *end = nullptr;
    errno = 0;
    const unsigned long long v = std::strtoull(s.c_str(), &end, 10);
    if (*end != '\0' || errno != 0) return false;
    if (v > max_val) return false;
    out = static_cast<uint64_t>(v);
    return true;
}

// Message builder: parse the -m string and emit a binary datagram.
// Returns the number of bytes written to out_buf; dies on invalid input.
static size_t build_message(const std::string &msg_str, uint8_t *out_buf) {
    const std::vector<std::string> parts = split_slash(msg_str);
    if (parts.empty())
        kaylescommon::die("invalid message string");

    uint64_t type_val = 0;
    if (!parse_uint64(parts[0], 255, type_val))
        kaylescommon::die("invalid msg_type in -m: '%s'", parts[0].c_str());

    const auto msg_type = static_cast<MsgType>(type_val);

    switch (msg_type) {
    case MsgType::join: {
        // Fields: 0/<player_id>
        if (parts.size() != 2)
            kaylescommon::die("MSG_JOIN requires exactly 2 fields (0/<player_id>)");
        uint64_t pid = 0;
        if (!parse_uint64(parts[1], 0xFFFFFFFFULL, pid) || pid == 0)
            kaylescommon::die("invalid player_id in MSG_JOIN: '%s'", parts[1].c_str());
        MsgJoin m;
        m.msg_type  = static_cast<uint8_t>(MsgType::join);
        m.player_id = htonl(static_cast<uint32_t>(pid));
        std::memcpy(out_buf, &m, sizeof(m));
        return sizeof(m);
    }
    case MsgType::move_one:
    case MsgType::move_two: {
        // Fields: 1/<player_id>/<game_id>/<pawn>  or  2/…
        if (parts.size() != 4)
            kaylescommon::die("MSG_MOVE_* requires 4 fields (type/<player_id>/<game_id>/<pawn>)");
        uint64_t pid = 0, gid = 0, pawn = 0;
        if (!parse_uint64(parts[1], 0xFFFFFFFFULL, pid) || pid == 0)
            kaylescommon::die("invalid player_id: '%s'", parts[1].c_str());
        if (!parse_uint64(parts[2], 0xFFFFFFFFULL, gid))
            kaylescommon::die("invalid game_id: '%s'", parts[2].c_str());
        if (!parse_uint64(parts[3], 255, pawn))
            kaylescommon::die("invalid pawn: '%s'", parts[3].c_str());
        if (msg_type == MsgType::move_one) {
            MsgMoveOne m;
            m.msg_type  = static_cast<uint8_t>(MsgType::move_one);
            m.player_id = htonl(static_cast<uint32_t>(pid));
            m.game_id   = htonl(static_cast<uint32_t>(gid));
            m.pawn      = static_cast<uint8_t>(pawn);
            std::memcpy(out_buf, &m, sizeof(m));
            return sizeof(m);
        } else {
            MsgMoveTwo m;
            m.msg_type  = static_cast<uint8_t>(MsgType::move_two);
            m.player_id = htonl(static_cast<uint32_t>(pid));
            m.game_id   = htonl(static_cast<uint32_t>(gid));
            m.pawn      = static_cast<uint8_t>(pawn);
            std::memcpy(out_buf, &m, sizeof(m));
            return sizeof(m);
        }
    }
    case MsgType::keep_alive: {
        // Fields: 3/<player_id>/<game_id>
        if (parts.size() != 3)
            kaylescommon::die("MSG_KEEP_ALIVE requires 3 fields (3/<player_id>/<game_id>)");
        uint64_t pid = 0, gid = 0;
        if (!parse_uint64(parts[1], 0xFFFFFFFFULL, pid) || pid == 0)
            kaylescommon::die("invalid player_id: '%s'", parts[1].c_str());
        if (!parse_uint64(parts[2], 0xFFFFFFFFULL, gid))
            kaylescommon::die("invalid game_id: '%s'", parts[2].c_str());
        MsgKeepAlive m;
        m.msg_type  = static_cast<uint8_t>(MsgType::keep_alive);
        m.player_id = htonl(static_cast<uint32_t>(pid));
        m.game_id   = htonl(static_cast<uint32_t>(gid));
        std::memcpy(out_buf, &m, sizeof(m));
        return sizeof(m);
    }
    case MsgType::give_up: {
        // Fields: 4/<player_id>/<game_id>
        if (parts.size() != 3)
            kaylescommon::die("MSG_GIVE_UP requires 3 fields (4/<player_id>/<game_id>)");
        uint64_t pid = 0, gid = 0;
        if (!parse_uint64(parts[1], 0xFFFFFFFFULL, pid) || pid == 0)
            kaylescommon::die("invalid player_id: '%s'", parts[1].c_str());
        if (!parse_uint64(parts[2], 0xFFFFFFFFULL, gid))
            kaylescommon::die("invalid game_id: '%s'", parts[2].c_str());
        MsgGiveUp m;
        m.msg_type  = static_cast<uint8_t>(MsgType::give_up);
        m.player_id = htonl(static_cast<uint32_t>(pid));
        m.game_id   = htonl(static_cast<uint32_t>(gid));
        std::memcpy(out_buf, &m, sizeof(m));
        return sizeof(m);
    }
    default:
        kaylescommon::die("unknown msg_type %u", static_cast<unsigned>(type_val));
    }
}

#endif // CLIENT_MESSAGE_H