server.cpp

/*
// server.cpp – Kayles game server.
//
// Single-process, single-threaded UDP state machine driven by incoming
// datagrams.
//
// Build:  see Makefile
// Usage:  kayles_server -r pawn_row -a address -p port -t server_timeout
*/

#include "protocol.h"
#include "helpers.h"
#include "server_config.h"
#include "pawn_row.h"

#include <arpa/inet.h>
#include <cerrno>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <netdb.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>

#include <algorithm>
#include <optional>
#include <string>
#include <unordered_map>
#include <vector>

// ────────────────────────────────────────────────────────────────────────────
// Extended game entry stored by the server
// ────────────────────────────────────────────────────────────────────────────

struct GameEntry {
    GameState state;

    /// Timestamps of last valid message from each player (for timeout).
    time_t last_msg_a {0};
    time_t last_msg_b {0};
};

// ────────────────────────────────────────────────────────────────────────────
// Server state
// ────────────────────────────────────────────────────────────────────────────

struct Server {
    int  sockfd  {-1};
    int  timeout {0};

    /// Pawn row template for new games (values constant per server run).
    uint8_t max_pawn {0};
    std::array<uint8_t, MAX_PAWN_ROW_SIZE> pawn_row_template {};

    /// All active + recently finished games, keyed by game_id.
    std::unordered_map<game_id_t, GameEntry> games;

    /// game_id of the current WAITING_FOR_OPPONENT game, if any.
    std::optional<game_id_t> waiting_game_id;

    /// Monotonically increasing counter for generating unique game IDs.
    /// Never reuse an ID.
    game_id_t next_game_id {0};
};

// ────────────────────────────────────────────────────────────────────────────
// Sending helpers
// ────────────────────────────────────────────────────────────────────────────

static void send_game_state(int sockfd,
                             const GameState &gs,
                             const sockaddr_in &dest) {
    uint8_t buf[MAX_SERVER_MSG];
    const size_t len = serialize_game_state(gs, buf);
    if (sendto(sockfd, buf, len, 0,
               reinterpret_cast<const sockaddr *>(&dest),
               sizeof(dest)) < 0) {
        std::perror("sendto (game_state)");
    }
}

static void send_wrong_msg(int sockfd,
                            const uint8_t *client_buf, size_t client_len,
                            uint8_t error_index,
                            const sockaddr_in &dest) {
    uint8_t buf[WRONG_MSG_SIZE];
    serialize_wrong_msg(client_buf, client_len, error_index, buf);
    if (sendto(sockfd, buf, WRONG_MSG_SIZE, 0,
               reinterpret_cast<const sockaddr *>(&dest),
               sizeof(dest)) < 0) {
        std::perror("sendto (wrong_msg)");
    }
}

// ────────────────────────────────────────────────────────────────────────────
// Timeout / cleanup
// ────────────────────────────────────────────────────────────────────────────

/// For a game in WAITING_FOR_OPPONENT: returns true if it should be removed
/// (no keep-alive from player A, no JOIN from player B within server_timeout).
static bool is_waiting_expired(const GameEntry &e, int timeout_sec) {
    return (serverhelper::now() - e.last_msg_a) >= timeout_sec;
}

/// For an active or finished game: returns true if it should be removed.
/// The deadline is server_timeout after the latest valid message from either player.
static bool is_active_expired(const GameEntry &e, int timeout_sec) {
    const time_t last = std::max(e.last_msg_a, e.last_msg_b);
    return (serverhelper::now() - last) >= timeout_sec;
}

/// Removes expired games and clears the waiting_game_id if needed.
static void expire_games(Server &srv) {
    auto it = srv.games.begin();
    while (it != srv.games.end()) {
        const GameEntry &e = it->second;
        bool expired = false;

        if (e.state.status == GameStatus::waiting_for_opponent) {
            expired = is_waiting_expired(e, srv.timeout);
        } else {
            expired = is_active_expired(e, srv.timeout);
        }

        if (expired) {
            if (srv.waiting_game_id && *srv.waiting_game_id == it->first) {
                srv.waiting_game_id.reset();
            }
            it = srv.games.erase(it);
        } else {
            ++it;
        }
    }
}

// ────────────────────────────────────────────────────────────────────────────
// Determine which player timed out in an active game and mark the result.
// ────────────────────────────────────────────────────────────────────────────

static void check_active_timeout(GameEntry &e, int timeout_sec) {
    if (e.state.status != GameStatus::turn_a &&
        e.state.status != GameStatus::turn_b) {
        return;  // already finished or waiting
    }
    const time_t t = serverhelper::now();
    const bool a_dead = (t - e.last_msg_a) >= timeout_sec;
    const bool b_dead = (t - e.last_msg_b) >= timeout_sec;

    if (a_dead)
        e.state.status = GameStatus::win_b;
    else if (b_dead)
        e.state.status = GameStatus::win_a;
}

// ────────────────────────────────────────────────────────────────────────────
// Game logic helpers
// ────────────────────────────────────────────────────────────────────────────

/// Returns true if the move "remove pawn p" is legal in state gs.
static bool is_move_one_legal(const GameState &gs, uint8_t p) {
    if (p > gs.max_pawn) return false;
    return gs.pawn_present(p);
}

/// Returns true if the move "remove pawns p and p+1" is legal in state gs.
static bool is_move_two_legal(const GameState &gs, uint8_t p) {
    if (p >= gs.max_pawn) return false;   // p+1 would exceed max_pawn
    return gs.pawn_present(p) && gs.pawn_present(p + 1);
}

/// Switches turn (TURN_A <-> TURN_B) and checks for win.
static void finalize_move(GameState &gs, bool was_turn_a) {
    if (!gs.any_pawn_present()) {
        gs.status = was_turn_a ? GameStatus::win_a : GameStatus::win_b;
    } else {
        gs.status = was_turn_a ? GameStatus::turn_b : GameStatus::turn_a;
    }
}

// ────────────────────────────────────────────────────────────────────────────
// Message dispatch
// ────────────────────────────────────────────────────────────────────────────

static void handle_join(Server &srv,
                         const uint8_t *buf, size_t len,
                         const sockaddr_in &src) {
    // Minimum size check: msg_type(1) + player_id(4) = 5 bytes.
    if (len < sizeof(MsgJoin)) {
        const uint8_t err = static_cast<uint8_t>(len);  // first missing byte
        send_wrong_msg(srv.sockfd, buf, len, err, src);
        return;
    } else if (len > sizeof(MsgJoin)) {
        // Extra bytes after the fixed-size struct: error at byte sizeof(MsgJoin).
        // We treat this as an error with error_index = 5,
        // i.e. the first unexpected byte after the fixed-size struct.
        send_wrong_msg(srv.sockfd, buf, len, 5, src);
        return;
    }

    MsgJoin msg;
    std::memcpy(&msg, buf, sizeof(msg));
    const player_id_t pid = ntohl(msg.player_id);

    if (pid == 0) {
        send_wrong_msg(srv.sockfd, buf, len, 1, src);
        return;
    }

    // ── Run lazy cleanup ──────────────────────────────────────────────────
    expire_games(srv);

    // ── No waiting game: create one ───────────────────────────────────────
    if (!srv.waiting_game_id) {
        // Check ID exhaustion: if next_game_id is already taken (after 2^32
        // games) we cannot allocate; silently ignore per spec.
        if (srv.games.count(srv.next_game_id) != 0) {
            return;
        }

        GameEntry entry;
        entry.state.game_id  = srv.next_game_id;
        entry.state.player_a = pid;
        entry.state.player_b = 0;
        entry.state.status   = GameStatus::waiting_for_opponent;
        entry.state.max_pawn = srv.max_pawn;
        entry.state.pawn_row = srv.pawn_row_template;
        entry.last_msg_a     = serverhelper::now();
        entry.last_msg_b     = 0;

        srv.waiting_game_id  = srv.next_game_id;
        srv.games.emplace(srv.next_game_id, entry);
        ++srv.next_game_id;

        send_game_state(srv.sockfd, entry.state, src);
        return;
    }

    // ── Waiting game exists: join as player B ─────────────────────────────
    GameEntry &entry = srv.games.at(*srv.waiting_game_id);
    entry.state.player_b = pid;
    entry.state.status   = GameStatus::turn_b;
    entry.last_msg_b     = serverhelper::now();
    srv.waiting_game_id.reset();

    send_game_state(srv.sockfd, entry.state, src);
}

// Helper: validate player_id + game_id for non-JOIN messages.
// Returns pointer to GameEntry on success, nullptr if an error was sent.
static GameEntry *validate_common(Server &srv,
                                   const uint8_t *buf, size_t len,
                                   size_t expected_len,
                                   const sockaddr_in &src,
                                   player_id_t &out_pid,
                                   game_id_t   &out_gid) {
    // Length check (msg_type already validated by caller).
    if (len < expected_len) {
        const uint8_t err = static_cast<uint8_t>(len);
        send_wrong_msg(srv.sockfd, buf, len, err, src);
        return nullptr;
    } else if (len > expected_len) {
        const uint8_t err = static_cast<uint8_t>(expected_len);
        send_wrong_msg(srv.sockfd, buf, len, err, src);
        return nullptr;
    }

    // player_id at offset 1 (4 bytes).
    uint32_t pid_net;
    std::memcpy(&pid_net, buf + 1, 4);
    out_pid = ntohl(pid_net);
    if (out_pid == 0) {
        send_wrong_msg(srv.sockfd, buf, len, 1, src);
        return nullptr;
    }

    // game_id at offset 5 (4 bytes).
    uint32_t gid_net;
    std::memcpy(&gid_net, buf + 5, 4);
    out_gid = ntohl(gid_net);

    auto it = srv.games.find(out_gid);
    if (it == srv.games.end()) {
        // game_id byte starts at offset 5.
        send_wrong_msg(srv.sockfd, buf, len, 5, src);
        return nullptr;
    }

    GameEntry &e = it->second;
    if (e.state.player_a != out_pid && e.state.player_b != out_pid) {
        // player_id is not a participant.
        send_wrong_msg(srv.sockfd, buf, len, 1, src);
        return nullptr;
    }

    return &e;
}

static void handle_move(Server &srv,
                          const uint8_t *buf, size_t len,
                          bool is_two,
                          const sockaddr_in &src) {
    const size_t expected = is_two ? sizeof(MsgMoveTwo) : sizeof(MsgMoveOne);
    player_id_t pid; game_id_t gid;
    GameEntry *ep = validate_common(srv, buf, len, expected, src, pid, gid);
    if (!ep) return;
    GameEntry &e = *ep;

    // Lazily update timeout state.
    check_active_timeout(e, srv.timeout);

    const uint8_t pawn = buf[expected - 1];  // last byte of either struct

    // Determine which player is moving.
    const bool is_a = (e.state.player_a == pid);

    // Update last-heard timestamp regardless of move legality.
    if (is_a) e.last_msg_a = serverhelper::now();
    else       e.last_msg_b = serverhelper::now();

    // Check: is the game in a state where moves are accepted?
    if (e.state.status != GameStatus::turn_a &&
        e.state.status != GameStatus::turn_b) {
        // Game is over; the move is illegal (state unchanged).
        send_game_state(srv.sockfd, e.state, src);
        return;
    }

    // Check whose turn it is.
    const bool expected_a = (e.state.status == GameStatus::turn_a);
    if (expected_a != is_a) {
        // Wrong player's turn – illegal move.
        send_game_state(srv.sockfd, e.state, src);
        return;
    }

    // Check move legality and apply.
    if (!is_two) {
        if (is_move_one_legal(e.state, pawn)) {
            e.state.set_pawn(pawn, false);
            finalize_move(e.state, is_a);
        }
        // else: illegal pawn value - state unchanged (still valid message).
    } else {
        if (is_move_two_legal(e.state, pawn)) {
            e.state.set_pawn(pawn,     false);
            e.state.set_pawn(pawn + 1, false);
            finalize_move(e.state, is_a);
        }
        // else: illegal - state unchanged.
    }

    send_game_state(srv.sockfd, e.state, src);
}

static void handle_keep_alive(Server &srv,
                                const uint8_t *buf, size_t len,
                                const sockaddr_in &src) {
    player_id_t pid; game_id_t gid;
    GameEntry *ep = validate_common(srv, buf, len,
                                    sizeof(MsgKeepAlive), src, pid, gid);
    if (!ep) return;
    GameEntry &e = *ep;

    const bool is_a = (e.state.player_a == pid);
    if (is_a) e.last_msg_a = serverhelper::now();
    else       e.last_msg_b = serverhelper::now();

    check_active_timeout(e, srv.timeout);
    send_game_state(srv.sockfd, e.state, src);
}

static void handle_give_up(Server &srv,
                             const uint8_t *buf, size_t len,
                             const sockaddr_in &src) {
    player_id_t pid; game_id_t gid;
    GameEntry *ep = validate_common(srv, buf, len,
                                    sizeof(MsgGiveUp), src, pid, gid);
    if (!ep) return;
    GameEntry &e = *ep;

    const bool is_a = (e.state.player_a == pid);

    // Update last-heard regardless.
    if (is_a) e.last_msg_a = serverhelper::now();
    else       e.last_msg_b = serverhelper::now();

    check_active_timeout(e, srv.timeout);

    // Give-up only legal when it is this player's turn.
    const bool legal = (is_a && e.state.status == GameStatus::turn_a) ||
                       (!is_a && e.state.status == GameStatus::turn_b);
    if (legal) {
        e.state.status = is_a ? GameStatus::win_b : GameStatus::win_a;
    }
    // If not the player's turn, it's an illegal give-up; state unchanged.

    send_game_state(srv.sockfd, e.state, src);
}

// ────────────────────────────────────────────────────────────────────────────
// Main receive / dispatch loop
// ────────────────────────────────────────────────────────────────────────────

static void run(Server &srv) {
    uint8_t buf[MAX_CLIENT_MSG];
    sockaddr_in src{};
    socklen_t src_len = sizeof(src);

    for (;;) {
        src_len = sizeof(src);
        const ssize_t n = recvfrom(srv.sockfd, buf, sizeof(buf), 0,
                                   reinterpret_cast<sockaddr *>(&src), &src_len);
        if (n < 0) {
            if (errno == EINTR) continue;
            std::perror("recvfrom");
            continue;
        }

        const size_t len = static_cast<size_t>(n);

        // Always run lazy cleanup on each received datagram.
        expire_games(srv);

        // Zero-length datagram: error_index = 0 (first missing byte = msg_type).
        if (len == 0) {
            send_wrong_msg(srv.sockfd, buf, 0, 0, src);
            continue;
        }

        const auto msg_type = static_cast<MsgType>(buf[0]);

        switch (msg_type) {
        case MsgType::join:
            handle_join(srv, buf, len, src);
            break;
        case MsgType::move_one:
            handle_move(srv, buf, len, false, src);
            break;
        case MsgType::move_two:
            handle_move(srv, buf, len, true, src);
            break;
        case MsgType::keep_alive:
            handle_keep_alive(srv, buf, len, src);
            break;
        case MsgType::give_up:
            handle_give_up(srv, buf, len, src);
            break;
        default:
            // Unknown msg_type: error at byte 0.
            send_wrong_msg(srv.sockfd, buf, len, 0, src);
            break;
        }
    }
}

// ────────────────────────────────────────────────────────────────────────────
// main
// ────────────────────────────────────────────────────────────────────────────

int main(int argc, char *argv[]) {
    const ServerConfig cfg = parse_args(argc, argv);

    Server srv;
    srv.timeout = cfg.server_timeout;
    init_pawn_template(cfg.pawn_row_str, srv.max_pawn, srv.pawn_row_template);

    // ── Create UDP socket ─────────────────────────────────────────────────
    srv.sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (srv.sockfd < 0)
        serverhelper::fatal("socket");

    // ── Resolve bind address ──────────────────────────────────────────────
    sockaddr_in bind_addr{};
    bind_addr.sin_family = AF_INET;
    bind_addr.sin_port   = htons(cfg.port);

    if (cfg.address == "0.0.0.0") {
        bind_addr.sin_addr.s_addr = INADDR_ANY;
    } else {
        if (inet_pton(AF_INET, cfg.address.c_str(),
                      &bind_addr.sin_addr) != 1) {
            addrinfo hints{};
            hints.ai_family   = AF_INET;
            hints.ai_socktype = SOCK_DGRAM;
            addrinfo *res = nullptr;
            const int rc = getaddrinfo(cfg.address.c_str(), nullptr, &hints, &res);
            if (rc != 0)
                kaylescommon::die("cannot resolve address '%s': %s",
                    cfg.address.c_str(), gai_strerror(rc));
            bind_addr.sin_addr =
                reinterpret_cast<sockaddr_in *>(res->ai_addr)->sin_addr;
            freeaddrinfo(res);
        }
    }

    if (bind(srv.sockfd,
             reinterpret_cast<sockaddr *>(&bind_addr),
             sizeof(bind_addr)) < 0)
        serverhelper::fatal("bind");

    // Report actual port if 0 was requested.
    if (cfg.port == 0) {
        sockaddr_in actual{};
        socklen_t actual_len = sizeof(actual);
        if (getsockname(srv.sockfd,
                        reinterpret_cast<sockaddr *>(&actual),
                        &actual_len) == 0) {
            std::printf("Listening on port %u\n", ntohs(actual.sin_port));
        }
    }

    run(srv);

    // Unreachable.
    close(srv.sockfd);
    return 0;
}