WebRTC Signaling

socket.emit("join-room", {
  roomCode: "ABC123",           // 6-character room code
  userId?: "user-123",          // Optional: authenticated user ID
  displayName: "John Doe",      // Display name for the participant
});

socket.on("room-joined", (data: {
  roomId: string;                    // Internal room UUID
  roomCode: string;                  // 6-character room code
  isHost: boolean;                   // Whether the user is the room host
  participants: ParticipantInfo[];   // Existing participants in the room
  messages: ChatMessage[];           // Recent chat messages (last 50)
  settings: RoomSettings;            // Room configuration
}) => {
  console.log("Joined room:", data.roomId);
});

interface ParticipantInfo {
  socketId: string;          // Socket.io connection ID
  userId?: string;           // User ID (if authenticated)
  displayName: string;       // Display name
  isHost: boolean;           // Host status
  isMuted: boolean;          // Audio muted status
  isVideoOff: boolean;       // Video off status
  isScreenSharing: boolean;  // Screen sharing status
  isHandRaised: boolean;     // Hand raised status
}

interface RoomSettings {
  allowScreenShare: boolean;  // Screen sharing enabled
  allowChat: boolean;         // Chat enabled
  waitingRoom: boolean;       // Waiting room enabled
}

socket.on("join-error", (data: {
  code: "JOIN_FAILED";
  message: string;  // e.g., "Room not found", "Room is locked", "Room is full"
}) => {
  console.error("Join failed:", data.message);
});

socket.emit("leave-room", {
  roomId: "room-uuid",
});

// Returns: { success: true }

socket.on("user-joined", (data: {
  participant: ParticipantInfo;
}) => {
  console.log(`${data.participant.displayName} joined`);
  // Create WebRTC offer to new participant
});

socket.on("user-left", (data: {
  socketId: string;
  userId?: string;
}) => {
  console.log(`User ${data.socketId} left`);
  // Close peer connection
});

socket.emit("offer", {
  targetId: "target-socket-id",   // Socket ID of the peer
  sdp: RTCSessionDescriptionInit, // SDP offer from RTCPeerConnection
});

socket.on("offer", async (data: {
  senderId: string;                // Socket ID of the sender
  userId?: string;                 // User ID of the sender
  displayName: string;             // Display name of the sender
  sdp: RTCSessionDescriptionInit;  // SDP offer
}) => {
  // Create peer connection and set remote description
  const pc = new RTCPeerConnection();
  await pc.setRemoteDescription(data.sdp);
  
  // Create and send answer
  const answer = await pc.createAnswer();
  await pc.setLocalDescription(answer);
  
  socket.emit("answer", {
    targetId: data.senderId,
    sdp: answer,
  });
});

socket.emit("answer", {
  targetId: "target-socket-id",
  sdp: RTCSessionDescriptionInit,
});

socket.on("answer", async (data: {
  senderId: string;
  sdp: RTCSessionDescriptionInit;
}) => {
  // Set remote description on peer connection
  await peerConnection.setRemoteDescription(data.sdp);
});

socket.emit("ice-candidate", {
  targetId: "target-socket-id",
  candidate: RTCIceCandidateInit,
});

socket.on("ice-candidate", async (data: {
  senderId: string;
  candidate: RTCIceCandidateInit;
}) => {
  // Add ICE candidate to peer connection
  await peerConnection.addIceCandidate(data.candidate);
});

socket.emit("toggle-audio", {
  roomId: "room-uuid",
  enabled: false,  // true = unmuted, false = muted
});

socket.on("user-toggle-audio", (data: {
  socketId: string;  // Socket ID of the user
  enabled: boolean;  // Audio status
}) => {
  console.log(`User ${data.socketId} ${data.enabled ? 'unmuted' : 'muted'}`);
});

socket.emit("toggle-video", {
  roomId: "room-uuid",
  enabled: true,  // true = camera on, false = camera off
});

socket.on("user-toggle-video", (data: {
  socketId: string;
  enabled: boolean;
}) => {
  console.log(`User ${data.socketId} turned video ${data.enabled ? 'on' : 'off'}`);
});

socket.emit("start-screen-share", {
  roomId: "room-uuid",
});

socket.on("screen-share-started", (data: {
  socketId: string;  // Socket ID of the user sharing
}) => {
  console.log(`User ${data.socketId} started screen sharing`);
});

socket.emit("stop-screen-share", {
  roomId: "room-uuid",
});

socket.on("screen-share-stopped", (data: {
  socketId: string;
}) => {
  console.log(`User ${data.socketId} stopped screen sharing`);
});

socket.emit("toggle-hand-raise", {
  roomId: "room-uuid",
  raised: true,  // true = raise hand, false = lower hand
});

socket.on("user-hand-raised", (data: {
  socketId: string;
  displayName: string;
}) => {
  console.log(`${data.displayName} raised their hand`);
});

socket.on("user-hand-lowered", (data: {
  socketId: string;
}) => {
  console.log(`User ${data.socketId} lowered their hand`);
});

socket.emit("mute-participant", {
  roomId: "room-uuid",
  targetId: "target-socket-id",
});

// Returns: { success: true } or { success: false, error: "Not authorized" }

socket.on("force-mute", () => {
  // Mute local audio
  console.log("You have been muted by the host");
});

socket.emit("remove-participant", {
  roomId: "room-uuid",
  targetId: "target-socket-id",
});

// Returns: { success: true } or { success: false, error: "Not authorized" }

socket.on("force-disconnect", (data: {
  reason: string;  // e.g., "Removed by host"
}) => {
  console.log("Kicked from room:", data.reason);
  // Disconnect and return to lobby
});

socket.emit("lock-room", {
  roomId: "room-uuid",
  locked: true,  // true = lock, false = unlock
});

// Returns: { success: true } or { success: false, error: "Not authorized" }

socket.on("room-locked", (data: {
  locked: boolean;
}) => {
  console.log(`Room is now ${data.locked ? 'locked' : 'unlocked'}`);
});

import { io, Socket } from "socket.io-client";

class WebRTCSignaling {
  private socket: Socket;
  private peerConnections: Map<string, RTCPeerConnection> = new Map();

  constructor(wsUrl: string, displayName: string) {
    this.socket = io(wsUrl, {
      auth: { displayName },
    });

    this.setupSignalingHandlers();
  }

  private setupSignalingHandlers() {
    // Room events
    this.socket.on("room-joined", (data) => {
      console.log("Joined room:", data.roomId);
      // Create offers to existing participants
      data.participants.forEach((p) => this.createOffer(p.socketId));
    });

    this.socket.on("user-joined", (data) => {
      console.log("User joined:", data.participant.displayName);
      // Wait for offer from new user
    });

    this.socket.on("user-left", (data) => {
      this.closePeerConnection(data.socketId);
    });

    // WebRTC signaling
    this.socket.on("offer", async (data) => {
      const pc = this.getOrCreatePeerConnection(data.senderId);
      await pc.setRemoteDescription(data.sdp);
      
      const answer = await pc.createAnswer();
      await pc.setLocalDescription(answer);
      
      this.socket.emit("answer", {
        targetId: data.senderId,
        sdp: answer,
      });
    });

    this.socket.on("answer", async (data) => {
      const pc = this.peerConnections.get(data.senderId);
      if (pc) {
        await pc.setRemoteDescription(data.sdp);
      }
    });

    this.socket.on("ice-candidate", async (data) => {
      const pc = this.peerConnections.get(data.senderId);
      if (pc) {
        await pc.addIceCandidate(data.candidate);
      }
    });

    // Media events
    this.socket.on("user-toggle-audio", (data) => {
      console.log(`User ${data.socketId} ${data.enabled ? 'unmuted' : 'muted'}`);
    });

    this.socket.on("user-toggle-video", (data) => {
      console.log(`User ${data.socketId} video ${data.enabled ? 'on' : 'off'}`);
    });
  }

  private getOrCreatePeerConnection(peerId: string): RTCPeerConnection {
    if (this.peerConnections.has(peerId)) {
      return this.peerConnections.get(peerId)!;
    }

    const pc = new RTCPeerConnection({
      iceServers: [
        { urls: "stun:stun.l.google.com:19302" },
      ],
    });

    // Send ICE candidates
    pc.onicecandidate = (event) => {
      if (event.candidate) {
        this.socket.emit("ice-candidate", {
          targetId: peerId,
          candidate: event.candidate.toJSON(),
        });
      }
    };

    // Handle remote stream
    pc.ontrack = (event) => {
      console.log("Received remote track from:", peerId);
      // Display remote stream
    };

    this.peerConnections.set(peerId, pc);
    return pc;
  }

  private async createOffer(peerId: string) {
    const pc = this.getOrCreatePeerConnection(peerId);
    
    const offer = await pc.createOffer();
    await pc.setLocalDescription(offer);
    
    this.socket.emit("offer", {
      targetId: peerId,
      sdp: offer,
    });
  }

  private closePeerConnection(peerId: string) {
    const pc = this.peerConnections.get(peerId);
    if (pc) {
      pc.close();
      this.peerConnections.delete(peerId);
    }
  }

  joinRoom(roomCode: string) {
    return new Promise((resolve, reject) => {
      this.socket.emit("join-room", {
        roomCode,
        displayName: "John Doe",
      });

      this.socket.once("room-joined", resolve);
      this.socket.once("join-error", (err) => reject(new Error(err.message)));
      setTimeout(() => reject(new Error("Join timeout")), 15000);
    });
  }

  toggleAudio(enabled: boolean) {
    const roomId = "current-room-id"; // Get from state
    this.socket.emit("toggle-audio", { roomId, enabled });
  }

  toggleVideo(enabled: boolean) {
    const roomId = "current-room-id"; // Get from state
    this.socket.emit("toggle-video", { roomId, enabled });
  }
}

Client A (existing)          Server          Client B (new)
     |                          |                    |
     |                          |    join-room       |
     |                          |<-------------------|
     |                          |                    |
     |      user-joined        |                    |
     |<-----------------------  |                    |
     |  (notifies about B)      |                    |
     |                          |   room-joined      |
     |                          |------------------->|
     |                          |  (includes A info) |
     |                          |                    |
     |         offer            |                    |
     |----------------------------------------->     |
     |                          |                    |
     |                          |      answer        |
     |<-----------------------------------------     |
     |                          |                    |
     |    ice-candidate         |                    |
     |<---------------------------------------->     |
     |                          |                    |

Client A                    Server          Other Clients
     |                          |                    |
     |    toggle-audio          |                    |
     |---------------------------->                  |
     |    (roomId, enabled)     |                    |
     |                          |                    |
     |                          | user-toggle-audio  |
     |                          |------------------->|
     |                          | (socketId, enabled)|
     |                          |                    |