websocket_client.h

Go to the documentation of this file.

#ifndef YAZE_APP_NET_WEBSOCKET_CLIENT_H_
#define YAZE_APP_NET_WEBSOCKET_CLIENT_H_
 
#include <functional>
#include <map>
#include <memory>
#include <string>
#include <thread>
#include <vector>
 
#include "absl/status/status.h"
#include "absl/status/statusor.h"
 
#ifdef YAZE_WITH_JSON
#include "nlohmann/json.hpp"
#endif
 
namespace yaze {
 
namespace net {
 
enum class ConnectionState {
  kDisconnected,
  kConnecting,
  kConnected,
  kReconnecting,
  kError
};
 
struct SessionInfo {
  std::string session_id;
  std::string session_code;
  std::string session_name;
  std::string host;
  std::vector<std::string> participants;
  std::string rom_hash;
  bool ai_enabled;
};
 
class WebSocketClient {
 public:
  // Message type callbacks
  using MessageCallback = std::function<void(const nlohmann::json&)>;
  using ErrorCallback = std::function<void(const std::string&)>;
  using StateCallback = std::function<void(ConnectionState)>;
 
  WebSocketClient();
  ~WebSocketClient();
 
  absl::Status Connect(const std::string& host, int port = 8765);
 
  void Disconnect();
 
  absl::StatusOr<SessionInfo> HostSession(const std::string& session_name,
                                          const std::string& username,
                                          const std::string& rom_hash,
                                          bool ai_enabled = true);
 
  absl::StatusOr<SessionInfo> JoinSession(const std::string& session_code,
                                          const std::string& username);
 
  absl::Status LeaveSession();
 
  absl::Status SendChatMessage(const std::string& message,
                               const std::string& sender);
 
  absl::Status SendRomSync(const std::string& diff_data,
                           const std::string& rom_hash,
                           const std::string& sender);
 
  absl::Status ShareSnapshot(const std::string& snapshot_data,
                             const std::string& snapshot_type,
                             const std::string& sender);
 
  absl::Status ShareProposal(const nlohmann::json& proposal_data,
                             const std::string& sender);
 
  absl::Status VoteOnProposal(const std::string& proposal_id, bool approved,
                              const std::string& username);
 
  absl::Status UpdateProposalStatus(const std::string& proposal_id,
                                    const std::string& status);
 
  absl::Status SendAIQuery(const std::string& query,
                           const std::string& username);
 
  void OnMessage(const std::string& type, MessageCallback callback);
 
  void OnError(ErrorCallback callback);
 
  void OnStateChange(StateCallback callback);
 
  ConnectionState GetState() const { return state_; }
 
  absl::StatusOr<SessionInfo> GetSessionInfo() const;
 
  bool IsConnected() const { return state_ == ConnectionState::kConnected; }
 
  bool InSession() const { return !current_session_.session_id.empty(); }
 
 private:
  // Implementation details (using native WebSocket or library)
  class Impl;
  std::unique_ptr<Impl> impl_;
 
  ConnectionState state_;
  SessionInfo current_session_;
 
  // Callbacks
  std::map<std::string, std::vector<MessageCallback>> message_callbacks_;
  std::vector<ErrorCallback> error_callbacks_;
  std::vector<StateCallback> state_callbacks_;
 
  // Internal message handling
  void HandleMessage(const std::string& message);
  void HandleError(const std::string& error);
  void SetState(ConnectionState state);
 
  // Send raw message
  absl::Status SendRaw(const nlohmann::json& message);
};
 
}  // namespace net
 
}  // namespace yaze
 
#endif  // YAZE_APP_NET_WEBSOCKET_CLIENT_H_