node build fixed

seanime-2.9.10/internal/nakama/handlers.go

@@ -0,0 +1,207 @@
+package nakama
+
+import (
+	"encoding/json"
+	"errors"
+	"seanime/internal/events"
+	"time"
+)
+
+// registerDefaultHandlers registers the default message handlers
+func (m *Manager) registerDefaultHandlers() {
+	m.messageHandlers[MessageTypeAuth] = m.handleAuthMessage
+	m.messageHandlers[MessageTypeAuthReply] = m.handleAuthReplyMessage
+	m.messageHandlers[MessageTypePing] = m.handlePingMessage
+	m.messageHandlers[MessageTypePong] = m.handlePongMessage
+	m.messageHandlers[MessageTypeError] = m.handleErrorMessage
+	m.messageHandlers[MessageTypeCustom] = m.handleCustomMessage
+
+	// Watch party handlers
+	m.messageHandlers[MessageTypeWatchPartyCreated] = m.handleWatchPartyMessage
+	m.messageHandlers[MessageTypeWatchPartyStopped] = m.handleWatchPartyMessage
+	m.messageHandlers[MessageTypeWatchPartyJoin] = m.handleWatchPartyMessage
+	m.messageHandlers[MessageTypeWatchPartyLeave] = m.handleWatchPartyMessage
+	m.messageHandlers[MessageTypeWatchPartyStateChanged] = m.handleWatchPartyMessage
+	m.messageHandlers[MessageTypeWatchPartyPlaybackStatus] = m.handleWatchPartyMessage
+	m.messageHandlers[MessageTypeWatchPartyPlaybackStopped] = m.handleWatchPartyMessage
+	m.messageHandlers[MessageTypeWatchPartyPeerStatus] = m.handleWatchPartyMessage
+	m.messageHandlers[MessageTypeWatchPartyBufferUpdate] = m.handleWatchPartyMessage
+	m.messageHandlers[MessageTypeWatchPartyRelayModeOriginStreamStarted] = m.handleWatchPartyMessage
+	m.messageHandlers[MessageTypeWatchPartyRelayModeOriginPlaybackStatus] = m.handleWatchPartyMessage
+	m.messageHandlers[MessageTypeWatchPartyRelayModePeersReady] = m.handleWatchPartyMessage
+	m.messageHandlers[MessageTypeWatchPartyRelayModePeerBuffering] = m.handleWatchPartyMessage
+	m.messageHandlers[MessageTypeWatchPartyRelayModeOriginPlaybackStopped] = m.handleWatchPartyMessage
+}
+
+// handleMessage routes messages to the appropriate handler
+func (m *Manager) handleMessage(message *Message, senderID string) error {
+	m.handlerMu.RLock()
+	handler, exists := m.messageHandlers[message.Type]
+	m.handlerMu.RUnlock()
+
+	if !exists {
+		return errors.New("unknown message type: " + string(message.Type))
+	}
+
+	return handler(message, senderID)
+}
+
+// handleAuthMessage handles authentication requests from peers
+func (m *Manager) handleAuthMessage(message *Message, senderID string) error {
+	if !m.settings.IsHost {
+		return errors.New("not acting as host")
+	}
+
+	// Parse auth payload
+	authData, err := json.Marshal(message.Payload)
+	if err != nil {
+		return err
+	}
+
+	var authPayload AuthPayload
+	if err := json.Unmarshal(authData, &authPayload); err != nil {
+		return err
+	}
+
+	// Get peer connection
+	peerConn, exists := m.peerConnections.Get(senderID)
+	if !exists {
+		return errors.New("peer connection not found")
+	}
+
+	// Verify password
+	success := authPayload.Password == m.settings.HostPassword
+	var replyMessage string
+	if success {
+		// Update the peer connection with the PeerID from auth payload if not already set
+		if peerConn.PeerId == "" && authPayload.PeerId != "" {
+			peerConn.PeerId = authPayload.PeerId
+		}
+
+		peerConn.Authenticated = true
+		replyMessage = "Authentication successful"
+		m.logger.Info().Str("peerID", peerConn.PeerId).Str("senderID", senderID).Msg("nakama: Peer authenticated successfully")
+
+		// Send event to client about new peer connection
+		m.wsEventManager.SendEvent(events.NakamaPeerConnected, map[string]interface{}{
+			"peerId":        peerConn.PeerId, // Use PeerID for events
+			"authenticated": true,
+		})
+	} else {
+		replyMessage = "Authentication failed"
+		m.logger.Warn().Str("peerId", peerConn.PeerId).Str("senderID", senderID).Msg("nakama: Peer authentication failed")
+	}
+
+	// Send auth reply
+	authReply := &Message{
+		Type: MessageTypeAuthReply,
+		Payload: AuthReplyPayload{
+			Success:  success,
+			Message:  replyMessage,
+			Username: m.username,
+			PeerId:   peerConn.PeerId, // Echo back the peer's UUID
+		},
+		Timestamp: time.Now(),
+	}
+
+	return peerConn.SendMessage(authReply)
+}
+
+// handleAuthReplyMessage handles authentication replies from hosts
+func (m *Manager) handleAuthReplyMessage(message *Message, senderID string) error {
+	// This should only be received by clients, and is handled in the client connection logic
+	// We can log it here for debugging purposes
+	m.logger.Debug().Str("senderID", senderID).Msg("nakama: Received auth reply")
+	return nil
+}
+
+// handlePingMessage handles ping messages
+func (m *Manager) handlePingMessage(message *Message, senderID string) error {
+	// Send pong response
+	pongMessage := &Message{
+		Type:      MessageTypePong,
+		Payload:   nil,
+		Timestamp: time.Now(),
+	}
+
+	if m.settings.IsHost {
+		// We're the host, send pong to peer
+		peerConn, exists := m.peerConnections.Get(senderID)
+		if !exists {
+			return errors.New("peer connection not found")
+		}
+		return peerConn.SendMessage(pongMessage)
+	} else {
+		// We're a client, send pong to host
+		m.hostMu.RLock()
+		defer m.hostMu.RUnlock()
+		if m.hostConnection == nil {
+			return errors.New("not connected to host")
+		}
+		return m.hostConnection.SendMessage(pongMessage)
+	}
+}
+
+// handlePongMessage handles pong messages
+func (m *Manager) handlePongMessage(message *Message, senderID string) error {
+	// Update last ping time
+	if m.settings.IsHost {
+		// Update peer's last ping time
+		peerConn, exists := m.peerConnections.Get(senderID)
+		if exists {
+			peerConn.LastPing = time.Now()
+		}
+	} else {
+		// Update host's last ping time
+		m.hostMu.Lock()
+		if m.hostConnection != nil {
+			m.hostConnection.LastPing = time.Now()
+		}
+		m.hostMu.Unlock()
+	}
+	return nil
+}
+
+// handleErrorMessage handles error messages
+func (m *Manager) handleErrorMessage(message *Message, senderID string) error {
+	// Parse error payload
+	errorData, err := json.Marshal(message.Payload)
+	if err != nil {
+		return err
+	}
+
+	var errorPayload ErrorPayload
+	if err := json.Unmarshal(errorData, &errorPayload); err != nil {
+		return err
+	}
+
+	m.logger.Error().Str("senderID", senderID).Str("errorMessage", errorPayload.Message).Str("errorCode", errorPayload.Code).Msg("nakama: Received error message")
+
+	// Send event to client about the error
+	m.wsEventManager.SendEvent(events.NakamaError, map[string]interface{}{
+		"senderID": senderID,
+		"message":  errorPayload.Message,
+		"code":     errorPayload.Code,
+	})
+
+	return nil
+}
+
+// handleCustomMessage handles custom messages
+func (m *Manager) handleCustomMessage(message *Message, senderID string) error {
+	m.logger.Debug().Str("senderID", senderID).Msg("nakama: Received custom message")
+
+	// Send event to client with the custom message
+	m.wsEventManager.SendEvent(events.NakamaCustomMessage, map[string]interface{}{
+		"senderID":  senderID,
+		"payload":   message.Payload,
+		"requestID": message.RequestID,
+		"timestamp": message.Timestamp,
+	})
+
+	return nil
+}
+
+func (m *Manager) handleWatchPartyMessage(message *Message, senderID string) error {
+	return m.watchPartyManager.handleMessage(message, senderID)
+}