goseg/ws/ws.go

package ws

import (
	"encoding/json"
	"fmt"
	"github.com/gorilla/websocket"
	"goseg/auth"
	"goseg/broadcast"
	"goseg/structs"
	"log/slog"
	"net/http"
	"os"
	"time"
)

var (
	logger   = slog.New(slog.NewJSONHandler(os.Stdout, nil))
	upgrader = websocket.Upgrader{
		ReadBufferSize:  1024,
		WriteBufferSize: 1024,
	}
)

// func handleConnection(c *websocket.Conn) {
//     // Read the first message from the client which should be the token
//     messageType, p, err := c.ReadMessage()
//     if err != nil {
//         logger.Error(fmt.Errorf("%v",err))
//         return
//     }
//     token := string(p)
//     // Verify the token
//     isValid, _, err := CheckToken(token, c, false)  // 'false' assumes it's not a setup
//     if !isValid || err != nil {
//         logger.Info("Invalid token provided by client.")
//         c.Close()
//         return
//     }

//     // rest of logic
// }


// switch on ws event cases
func WsHandler(w http.ResponseWriter, r *http.Request) {
	conn, err := upgrader.Upgrade(w, r, nil)
	if err != nil {
		fmt.Println(err)
		return
	}
	// manage broadcasts and clients thru the broadcast package
	broadcast.RegisterClient(conn)
	defer broadcast.UnregisterClient(conn)
	// keepalive for ws
	conn.SetPongHandler(func(string) error {
		conn.SetReadDeadline(time.Now().Add(60 * time.Second))
		return nil
	})
	pingInterval := 15 * time.Second
	go func() {
		ticker := time.NewTicker(pingInterval)
		defer ticker.Stop()
		for {
			select {
			case <-ticker.C:
				if err := conn.WriteMessage(websocket.PingMessage, nil); err != nil {
					return
				}
			}
		}
	}()
	for {
		_, msg, err := conn.ReadMessage()
		if err != nil {
			return
		}
		var prelim structs.WsType
		if err := json.Unmarshal(msg, &prelim); err != nil {
			fmt.Println("Error unmarshalling message:", err)
			continue
		}
		switch prelim.Payload.Type {
		case "login":
			var payload structs.WsPayload
			payload.Payload = structs.LoginPayload{}
			if err := json.Unmarshal(msg, &payload); err != nil {
				fmt.Println("Error unmarshalling message:", err)
				continue
			}
			loginPayload, ok := payload.Payload.(structs.LoginPayload)
			if !ok {
				fmt.Println("Error casting to LoginPayload")
				continue
			}
			isAuthenticated := auth.AuthenticateLogin(loginPayload.Password)
			if isAuthenticated {
				_, err := auth.CreateToken(conn, false)
				if err != nil {
					fmt.Println("Error creating token:", err)
					continue
				}
				auth.AuthenticatedClients.Lock()
				auth.AuthenticatedClients.Conns[conn] = true
				auth.AuthenticatedClients.Unlock()
                } else {
                    // Handle invalid login
                    fmt.Println("Invalid login attempt")
                }
		case "setup":
			logger.Info("Setup")
			// setup.Setup(payload)
		case "new_ship":
			logger.Info("New ship")
		case "pier_upload":
			logger.Info("Pier upload")
		case "password":
			logger.Info("Password")
		case "system":
			logger.Info("System")
		case "startram":
			logger.Info("StarTram")
		case "urbit":
			logger.Info("Urbit")
		case "support":
			logger.Info("Support")
		case "broadcast":
			if err := broadcast.BroadcastToClients(); err != nil {
				errmsg := fmt.Sprintf("Unable to broadcast to peer(s): %v", err)
				logger.Error(errmsg)
			}
		default:
			errmsg := fmt.Sprintf("Unknown request type: %s", prelim.Payload.Type)
			logger.Warn(errmsg)
		}
	}
}