client.hpp

Go to the documentation of this file.

#pragma once
 
#include <string>
#include <functional>
#include <thread>
#include <atomic>
#include <mutex>
#include <optional>
#include <future>
#include <sockpp/tcp_connector.h>
 
#include "protocol/protocol.hpp"
 
class Client
{
public:
    // Callback types
    using DisconnectedCallback = std::function<void()>;
    using GameStateUpdateCallback = std::function<void(const GameStateUpdate &)>;
    using MoveResultCallback = std::function<void(bool success, const std::string &message)>;
    using ErrorCallback = std::function<void(uint16_t error_code, const std::string &message)>;
 
    Client();
    ~Client();
 
    // ========================================================================
    // Connection Management
    // ========================================================================
 
    bool connect(const std::string &host, uint16_t port);
 
    void disconnect();
 
    bool isConnected() const { return connected_; }
 
    bool isRunning() const { return running_; }
 
    void run();
 
    void stop();
 
    // ========================================================================
    // Game Actions
    // ========================================================================
 
    bool sendConnectRequest(const std::string &player_name);
 
    bool sendCreateGame(const GameConfig &config, const std::string &name = "");
 
    bool sendListGames();
 
    bool sendJoinGame(uint32_t game_id);
 
    bool sendMove(uint8_t column);
 
    bool sendDisconnect(const std::string &reason = "Client disconnecting");
 
    // ===========================================================================
    // Synchronous Requests
    // ===========================================================================
    std::optional<ConnectResponse> requestConnect(const std::string &player_name, int timeout_ms = 3000);
    std::optional<CreateGameResponse> requestCreateGame(const GameConfig &config, const std::string &name = "", int timeout_ms = 3000);
    std::optional<ListGamesResponse> requestGamesList(int timeout_ms = 3000);
    std::optional<JoinGameResponse> requestJoinGame(uint32_t game_id, int timeout_ms = 3000);
 
    // ========================================================================
    // Callbacks (set these to handle events)
    // ========================================================================
 
    void onDisconnected(DisconnectedCallback callback)
    {
        disconnected_callback_ = callback;
    }
 
    void onGameStateUpdate(GameStateUpdateCallback callback)
    {
        game_state_callback_ = callback;
    }
 
    void onMoveResult(MoveResultCallback callback)
    {
        move_result_callback_ = callback;
    }
 
    void onError(ErrorCallback callback)
    {
        error_callback_ = callback;
    }
 
    // ========================================================================
    // State Accessors
    // ========================================================================
 
    const std::string &getSessionToken() const { return session_token_; }
 
    uint8_t getPlayerId() const { return player_id_; }
 
    std::optional<uint8_t> getPlayerIndex(const GameStateUpdate &state, uint8_t player_id)
    {
        auto it = std::find(state.players.begin(), state.players.end(), player_id);
        if (it != state.players.end())
        {
            return std::distance(state.players.begin(), it);
        }
        return std::nullopt;
    }
 
    const std::optional<GameInfo> &getGameInfo() const { return game_info_; }
 
    uint32_t getGameId() const { return game_info_.has_value() ? game_info_->game_id : 0; }
 
    std::string getGameName() const { return game_info_.has_value() ? game_info_->game_name : std::string(); }
 
    const std::optional<GameStateUpdate> &getCurrentState() const
    {
        return current_state_;
    }
 
    bool isMyTurn() const
    {
        if (!current_state_.has_value() || current_state_->status != ProtocolGameStatus::IN_PROGRESS)
            return false;
        return current_state_->current_player == player_id_;
    }
 
private:
    // Network
    sockpp::tcp_connector socket_;
    std::atomic<bool> connected_;
    std::atomic<bool> running_;
 
    // Session state
    std::string session_token_;
    uint8_t player_id_;
    std::optional<GameInfo> game_info_;
    std::optional<GameStateUpdate> current_state_;
    std::mutex state_mutex_;
 
    // Promise management for responses
    std::mutex promise_mutex_;
    std::unordered_map<MessageType, std::promise<std::string>> pending_promises_;
 
    // Callbacks
    DisconnectedCallback disconnected_callback_;
    GameStateUpdateCallback game_state_callback_;
    MoveResultCallback move_result_callback_;
    ErrorCallback error_callback_;
 
    // Internal methods
    bool sendMessage(MessageType type, const std::string &payload);
    std::optional<std::string> waitForResponse(MessageType type, std::chrono::milliseconds timeout);
    std::string readMessage();
    bool writeMessage(const std::string &message);
    void processMessage(const std::string &data);
 
    // Message handlers
    void handleGameStateUpdate(const std::string &payload);
    void handleMoveResult(const std::string &payload);
    void handleError(const std::string &payload);
};