wasm_collaboration.h

Go to the documentation of this file.

#ifndef YAZE_APP_PLATFORM_WASM_COLLABORATION_H_
#define YAZE_APP_PLATFORM_WASM_COLLABORATION_H_
 
#ifdef __EMSCRIPTEN__
 
#include <emscripten.h>
#include <emscripten/html5.h>
#include <emscripten/val.h>
 
#include <functional>
#include <map>
#include <memory>
#include <mutex>
#include <string>
#include <vector>
 
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "app/net/wasm/emscripten_websocket.h"
#include "rom/rom.h"
 
namespace yaze {
namespace app {
namespace platform {
 
class WasmCollaboration {
 public:
  struct User {
    std::string id;
    std::string name;
    std::string color;  // Hex color for cursor/highlights
    bool is_active = true;
    double last_activity = 0;  // Timestamp
  };
 
  struct CursorInfo {
    std::string user_id;
    std::string editor_type;  // "overworld", "dungeon", etc.
    int x = 0;
    int y = 0;
    int map_id = -1;  // For context (which map/room)
  };
 
  struct ChangeEvent {
    uint32_t offset;
    std::vector<uint8_t> old_data;
    std::vector<uint8_t> new_data;
    std::string user_id;
    double timestamp;
  };
 
  // Connection state enum
  enum class ConnectionState {
    Disconnected,
    Connecting,
    Connected,
    Reconnecting
  };
 
  // Callbacks for UI updates
  using UserListCallback = std::function<void(const std::vector<User>&)>;
  using ChangeCallback = std::function<void(const ChangeEvent&)>;
  using CursorCallback = std::function<void(const CursorInfo&)>;
  using StatusCallback = std::function<void(bool connected, const std::string& message)>;
  using ConnectionStateCallback = std::function<void(ConnectionState state, const std::string& message)>;
 
  WasmCollaboration();
  ~WasmCollaboration();
 
  absl::Status SetWebSocketUrl(const std::string& url) {
    if (url.empty()) {
      websocket_url_.clear();
      return absl::OkStatus();
    }
    if (url.find("ws://") != 0 && url.find("wss://") != 0) {
      return absl::InvalidArgumentError(
          "WebSocket URL must start with ws:// or wss://");
    }
    // Basic URL structure validation
    if (url.length() < 8) {  // Minimum: "ws://x" or "wss://x"
      return absl::InvalidArgumentError("WebSocket URL is too short");
    }
    websocket_url_ = url;
    return absl::OkStatus();
  }
 
  std::string GetWebSocketUrl() const { return websocket_url_; }
 
  void InitializeFromConfig();
 
  bool IsConfigured() const { return !websocket_url_.empty(); }
 
  absl::StatusOr<std::string> CreateSession(const std::string& session_name,
                                           const std::string& username,
                                           const std::string& password = "");
 
  absl::Status JoinSession(const std::string& room_code,
                          const std::string& username,
                          const std::string& password = "");
 
  absl::Status LeaveSession();
 
  absl::Status BroadcastChange(uint32_t offset,
                               const std::vector<uint8_t>& old_data,
                               const std::vector<uint8_t>& new_data);
 
  absl::Status SendCursorPosition(const std::string& editor_type,
                                  int x, int y, int map_id = -1);
 
  void SetRom(Rom* rom) { rom_ = rom; }
 
  void SetChangeCallback(ChangeCallback callback) {
    change_callback_ = callback;
  }
 
  void SetUserListCallback(UserListCallback callback) {
    user_list_callback_ = callback;
  }
 
  void SetCursorCallback(CursorCallback callback) {
    cursor_callback_ = callback;
  }
 
  void SetStatusCallback(StatusCallback callback) {
    status_callback_ = callback;
  }
 
  void SetConnectionStateCallback(ConnectionStateCallback callback) {
    connection_state_callback_ = callback;
  }
 
  ConnectionState GetConnectionState() const {
    return connection_state_;
  }
 
  std::vector<User> GetConnectedUsers() const;
 
  bool IsConnected() const;
 
  bool IsApplyingRemoteChange() const { return applying_remote_change_; }
 
  std::string GetRoomCode() const { return room_code_; }
 
  std::string GetSessionName() const { return session_name_; }
 
  std::string GetUserId() const { return user_id_; }
 
  void SetAutoResolveConflicts(bool enable) {
    auto_resolve_conflicts_ = enable;
  }
 
  void ProcessPendingChanges();
 
 private:
  // WebSocket message handlers
  void HandleMessage(const std::string& message);
  void HandleCreateResponse(const emscripten::val& data);
  void HandleJoinResponse(const emscripten::val& data);
  void HandleUserList(const emscripten::val& data);
  void HandleChange(const emscripten::val& data);
  void HandleCursor(const emscripten::val& data);
  void HandleError(const emscripten::val& data);
 
  // Utility methods
  std::string GenerateUserId();
  std::string GenerateUserColor();
  void UpdateUserActivity(const std::string& user_id);
  void CheckUserTimeouts();
  bool IsChangeValid(const ChangeEvent& change);
  void ApplyRemoteChange(const ChangeEvent& change);
 
  // Reconnection management
  void InitiateReconnection();
  void AttemptReconnection();
  void ResetReconnectionState();
  void UpdateConnectionState(ConnectionState new_state, const std::string& message);
  void QueueMessageWhileDisconnected(const std::string& message);
 
  // Connection management
  std::unique_ptr<net::EmscriptenWebSocket> websocket_;
  bool is_connected_ = false;
  ConnectionState connection_state_ = ConnectionState::Disconnected;
  std::string websocket_url_;  // Set via SetWebSocketUrl() or environment
 
  // Reconnection state
  int reconnection_attempts_ = 0;
  int max_reconnection_attempts_ = 10;
  double reconnection_delay_seconds_ = 1.0;  // Initial delay
  double max_reconnection_delay_ = 30.0;  // Max delay between attempts
  bool should_reconnect_ = false;
  std::string stored_password_;  // Store password for reconnection
 
  // Session state
  std::string room_code_;
  std::string session_name_;
  std::string user_id_;
  std::string username_;
  std::string user_color_;
 
  // Connected users
  std::map<std::string, User> users_;
  mutable std::mutex users_mutex_;
 
  // Remote cursors
  std::map<std::string, CursorInfo> cursors_;
  mutable std::mutex cursors_mutex_;
 
  // Change queue for conflict resolution
  std::vector<ChangeEvent> pending_changes_;
  mutable std::mutex changes_mutex_;
 
  // Message queue for disconnected state
  std::vector<std::string> queued_messages_;
  mutable std::mutex message_queue_mutex_;
  size_t max_queued_messages_ = 100;  // Limit queue size
 
  // Configuration
  bool auto_resolve_conflicts_ = true;
 
  // Callbacks
  UserListCallback user_list_callback_;
  ChangeCallback change_callback_;
  CursorCallback cursor_callback_;
  StatusCallback status_callback_;
  ConnectionStateCallback connection_state_callback_;
 
  // ROM reference for applying changes
  Rom* rom_ = nullptr;
 
  // Rate limiting
  double last_cursor_send_ = 0;
 
  // Guard to prevent echoing remote writes back to the server
  bool applying_remote_change_ = false;
};
 
// Singleton accessor used by JS bindings and the WASM main loop
WasmCollaboration& GetWasmCollaborationInstance();
 
}  // namespace platform
}  // namespace app
}  // namespace yaze
 
#else  // !__EMSCRIPTEN__
 
// Stub for non-WASM builds
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include <string>
#include <vector>
 
namespace yaze {
namespace app {
namespace platform {
 
class WasmCollaboration {
 public:
  struct User {
    std::string id;
    std::string name;
    std::string color;
    bool is_active = true;
  };
 
  struct CursorInfo {
    std::string user_id;
    std::string editor_type;
    int x = 0;
    int y = 0;
    int map_id = -1;
  };
 
  struct ChangeEvent {
    uint32_t offset;
    std::vector<uint8_t> old_data;
    std::vector<uint8_t> new_data;
    std::string user_id;
    double timestamp;
  };
 
  absl::StatusOr<std::string> CreateSession(const std::string&,
                                           const std::string&) {
    return absl::UnimplementedError("Collaboration requires WASM build");
  }
 
  absl::Status JoinSession(const std::string&, const std::string&) {
    return absl::UnimplementedError("Collaboration requires WASM build");
  }
 
  absl::Status LeaveSession() {
    return absl::UnimplementedError("Collaboration requires WASM build");
  }
 
  absl::Status BroadcastChange(uint32_t, const std::vector<uint8_t>&,
                               const std::vector<uint8_t>&) {
    return absl::UnimplementedError("Collaboration requires WASM build");
  }
 
  std::vector<User> GetConnectedUsers() const { return {}; }
  bool IsConnected() const { return false; }
  std::string GetRoomCode() const { return ""; }
  std::string GetSessionName() const { return ""; }
};
 
}  // namespace platform
}  // namespace app
}  // namespace yaze
 
#endif  // __EMSCRIPTEN__
 
#endif  // YAZE_APP_PLATFORM_WASM_COLLABORATION_H_