handlers -> first poc

backend/handler/message.go

@@ -2,17 +2,22 @@ package handler
 
 import (
 	"github.com/0xlaurens/filefa.st/service"
+	"github.com/0xlaurens/filefa.st/types"
 	"github.com/gofiber/contrib/websocket"
+	"log"
 )
 
-type messageHandler func(c *websocket.Conn) (string, error)
+type messageHandler func(c *websocket.Conn, notifier service.MessageNotifier, raw interface{}) error
 
 var responseMap = map[string]messageHandler{
-	"OFFER":             handleOffer,
-	"ANSWER":            handleAnswer,
-	"CANDIDATE":         handleCandidate,
-	"USER_CONNECTED":    handleUserConnected,
-	"USER_DISCONNECTED": handleUserDisconnected,
+	types.Offer:       handleOffer,
+	types.Answer:      handleAnswer,
+	types.Candidate:   handleCandidate,
+	types.JoinRoom:    handleJoinRoom,
+	types.LeaveRoom:   handleLeaveRoom,
+	types.RequestRoom: handleRequestRoom,
+	types.RoomExists:  handleRoomExists,
+	_:                 handleUnknown,
 }
 
 type MessageHandler struct {
@@ -25,36 +30,75 @@ func NewMessageHandler(notifier service.MessageNotifier) *MessageHandler {
 	}
 }
 
-func (mh *MessageHandler) handleResponse(c *websocket.Conn, msg string) {
-	handler, ok := responseMap[msg]
+func (mh *MessageHandler) handleResponse(c *websocket.Conn, reqType string, raw interface{}) error {
+	handler, ok := responseMap[reqType]
 	if !ok {
-		return
+		return nil
 	}
-	_, _ = handler(c)
-	return
+	return handler(c, mh.notifier, raw)
 }
 
-func handleOffer(c *websocket.Conn) (string, error) {
-	//TODO: Implement
-	panic("implement me")
+func handleOffer(c *websocket.Conn, notifier service.MessageNotifier, raw interface{}) error {
+	msg, ok := raw.(types.OfferAnswerMessage)
+	if !ok {
+		log.Println("Could not cast to OfferAnswerMessage")
+		return nil
+	}
+
+	notifier.SendMessage(msg, msg.RoomID, msg.To)
+
+	return nil
 }
 
-func handleUserDisconnected(c *websocket.Conn) (string, error) {
-	//TODO: Implement
-	panic("implement me")
+func handleAnswer(c *websocket.Conn, notifier service.MessageNotifier, raw interface{}) error {
+	msg, ok := raw.(types.OfferAnswerMessage)
+	if !ok {
+		log.Println("Could not cast to OfferAnswerMessage")
+		return nil
+	}
+
+	return notifier.SendMessage(msg, msg.RoomID, msg.To)
 }
 
-func handleUserConnected(c *websocket.Conn) (string, error) {
+func handleCandidate(c *websocket.Conn, notifier service.MessageNotifier, raw interface{}) error {
+	msg, ok := raw.(types.CandidateMessage)
+	if !ok {
+		log.Println("Could not cast to CandidateMessage")
+		return nil
+	}
+
+	return notifier.BroadcastMessage(msg, msg.RoomID)
+}
+
+func handleJoinRoom(c *websocket.Conn, notifier service.MessageNotifier, raw interface{}) error {
+	_, ok := raw.(types.JoinRoomMessage)
+	if !ok {
+		log.Println("Could not cast to JoinRoomMessage")
+		return nil
+	}
+	// get room
+	// add user to room
+	// send message to user
+	// send message to all other users that user has joined
+	return nil
+}
+
+func handleLeaveRoom(c *websocket.Conn, notifier service.MessageNotifier, raw interface{}) error {
 	//TODO: Implement
 	panic("implement me")
 }
 
-func handleCandidate(c *websocket.Conn) (string, error) {
+func handleRequestRoom(c *websocket.Conn, notifier service.MessageNotifier, raw interface{}) error {
 	//TODO: Implement
 	panic("implement me")
 }
 
-func handleAnswer(c *websocket.Conn) (string, error) {
+func handleRoomExists(c *websocket.Conn, notifier service.MessageNotifier, raw interface{}) error {
 	//TODO: Implement
 	panic("implement me")
 }
+
+func handleUnknown(c *websocket.Conn, notifier service.MessageNotifier, raw interface{}) error {
+	log.Println("Unknown message type")
+	return nil
+}

backend/handler/websocket.go

@@ -10,12 +10,14 @@ import (
 )
 
 type WebsocketHandler struct {
-	roomService service.RoomManagement
+	roomService    service.RoomManagement
+	messageHandler *MessageHandler
 }
 
 func NewWebsocketHandler(roomService service.RoomManagement) *WebsocketHandler {
 	return &WebsocketHandler{
-		roomService: roomService,
+		roomService:    roomService,
+		messageHandler: NewMessageHandler(service.NewWebsocketNotifier(roomService)),
 	}
 }
 
@@ -31,42 +33,29 @@ func (wh *WebsocketHandler) HandleWebsocket(conn *websocket.Conn) error {
 	os := ua.OSInfo().Name
 
 	user := types.CreateUser(os, types.WithConnection(conn))
-	log.Printf("New user connected: %s\n", user.DisplayName)
+	log.Println("User connected:", user.ID)
 
-	room, err := wh.roomService.CreateRoom()
-	if err != nil {
-		return err
-	}
-
-	_, err = wh.roomService.JoinRoom(room.Code, user)
-	if err != nil {
-		log.Println("Error joining room:", err)
-		return err
-	}
-	defer func(roomService service.RoomManagement, code string, user *types.User) {
-		_, err := roomService.LeaveRoom(code, user)
-		if err != nil {
-			log.Println("Error leaving room:", err)
-			return
-		}
-	}(wh.roomService, room.Code, user)
-
-	rooms := wh.roomService.GetAllRooms()
-	log.Println("All rooms:", rooms)
+	defer conn.Close()
 
 	conn.WriteJSON(fiber.Map{
-		"type": "USER_CONNECTED",
+		"type": "IDENTITY",
 		"user": user,
 	})
 
 	for {
-		_, msg, err := conn.ReadMessage()
+		var raw interface{}
+		err := conn.ReadJSON(&raw)
 		if err != nil {
 			log.Println("Error reading message:", err)
 			break
 		}
+		req := raw.(types.Message)
 
-		log.Printf("%s: %s", user.DisplayName, string(msg))
+		err = wh.messageHandler.handleResponse(conn, req.Type, raw)
+		if err != nil {
+			return err
+		}
 	}
+
 	return nil
 }