out/cmd/server/ws.go

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"slices"
	"strconv"
	"strings"
	"time"

	"github.com/coder/websocket"
)

func isWS(r *http.Request) bool {
	return r.URL.Path == "/ws" || strings.HasPrefix(r.URL.Path, "/ws/")
}

func (s *S) serveWS(w http.ResponseWriter, r *http.Request) error {
	ctx, can := context.WithCancel(r.Context())
	defer can()
	r = r.WithContext(ctx)

	session := s.Session(ctx)
	games, err := s.games.GamesForUser(ctx, session.ID)
	if err != nil {
		return err
	}
	if len(games) == 0 {
		return fmt.Errorf("user %s is in zero games", session.ID)
	}
	game := games[0]

	c, err := websocket.Accept(w, r, nil)
	if err != nil {
		return err
	}
	defer c.CloseNow()

	go func() {
		defer can()
		for {
			_, b, err := c.Read(ctx)
			if err != nil {
				log.Println(err)
				return
			}
			log.Printf("READ %s", b)

			var m map[string]string
			if err := json.Unmarshal(b, &m); err != nil {
				log.Println(err)
				return
			}
			log.Printf("UNMARSHAL %+v", m)

			if m["party"] == "start" {
				if gameState, err := s.games.GameState(ctx, game); err != nil {
					log.Println(err)
					return
				} else if gameState.Started {
				} else if err := s.games.CreateEventAssignmentRotation(ctx, game, "", "", "", 0); err != nil {
					log.Println(err)
					return
				}
			} else if m["k"] != "" {
				log.Println("TODO a kill occurred")
				return
			} else if name := m["name"]; name != "" {
				if err := s.games.UpdateUserName(ctx, s.Session(ctx).ID, name); err != nil {
					log.Println(err)
					return
				}
			} else if m["again"] == "true" {
				if gameState, err := s.games.GameState(ctx, game); err != nil {
					log.Println(err)
					return
				} else if gameState.Completed.IsZero() {
				} else {
					log.Println("TODO new game")
					return
				}
			} else {
				log.Printf("UNKNOWN: %+v", m)
				return
			}
		}
	}()

	var last time.Time
	for {
		select {
		case <-ctx.Done():
			return ctx.Err()
		case <-time.After(time.Second * 1):
		}

		if events, err := s.games.GameEvents(ctx, game, last); err != nil {
			return err
		} else if len(events) == 0 {
			continue
		}
		last = time.Now()

		gameState, err := s.games.GameState(ctx, game)
		if err != nil {
			return err
		}

		msg := map[string]any{
			"help": strings.Join([]string{
				"CARD ASSASSINS (Mobile Ed.)",
				"",
				"1. Get any target to say any of his or her kill words.",
				"2. Click on the kill word a target said.",
				"",
				"The game ends when everyone has been assassinated.",
			}, "<br>"),
		}

		if gameState.Started {
			msg["page"] = "B"
			if gameState.Completed.IsZero() {
				msg["event"] = "A"
				items := []map[string]any{}
				for k, v := range gameState.Players {
					if k == s.Session(ctx).ID {
						continue
					}

					name, err := s.games.UserName(ctx, k)
					if err != nil {
						return err
					}

					tags := []map[string]any{}
					if self := gameState.Players[s.Session(ctx).ID]; self.KillWords.Assignee == k {
						for _, private := range v.KillWords.Assignment.Private {
							tags = append(tags, map[string]any{
								"k": private.Word,
								"v": private.Points,
							})
						}
					}
					for _, public := range v.KillWords.Assignment.Public {
						tags = append(tags, map[string]any{
							"k": public.Word,
							"v": public.Points,
						})
					}
					if self := gameState.Players[s.Session(ctx).ID]; !slices.ContainsFunc(self.Kills, func(a Kill) bool {
						return a.Victim == k
					}) {
						tags = append(tags, map[string]any{
							"k": self.KillWords.Global.Word,
							"v": self.KillWords.Global.Points,
						})
					}

					items = append(items, map[string]any{
						"name":  name,
						"title": strconv.Itoa(v.Points()),
						"tags":  tags,
					})
				}
				slices.SortFunc(items, func(a, b map[string]any) int {
					an, _ := strconv.Atoi(fmt.Sprint(a["title"]))
					bn, _ := strconv.Atoi(fmt.Sprint(b["title"]))
					return an - bn
				})
				return io.EOF
			} else {
				msg["event"] = "B"
				items := []map[string]any{}
				for k, v := range gameState.Players {
					name, err := s.games.UserName(ctx, k)
					if err != nil {
						return err
					}
					tags := []map[string]any{}
					for _, kill := range v.Kills {
						tags = append(tags, map[string]any{
							"k": kill.KillWord.Word,
							"v": kill.Victim,
						})
					}
					items = append(items, map[string]any{
						"name":  name,
						"title": fmt.Sprint(v.Points()),
						"tags":  tags,
					})
				}
				msg["items"] = items
			}
		} else {
			msg["page"] = "A"
			items := []map[string]any{}
			for k := range gameState.Players {
				name, err := s.games.UserName(ctx, k)
				if err != nil {
					return err
				}
				items = append(items, map[string]any{"name": name})
			}
			msg["items"] = items
		}

		msgB, _ := json.Marshal(msg)
		if err := c.Write(ctx, 1, msgB); err != nil {
			return err
		}
	}
}