Feat: works on my machine

handlers/wordle/getState.go

@@ -0,0 +1,55 @@
+package wordle
+
+import (
+	"net/http"
+
+	"gitea.konchin.com/ytshih/inp2025/middlewares"
+	"gitea.konchin.com/ytshih/inp2025/types"
+	"gitea.konchin.com/ytshih/inp2025/utils"
+	"github.com/gorilla/websocket"
+	"github.com/uptrace/bunrouter"
+	"github.com/vmihailenco/msgpack/v5"
+)
+
+func (self *Handlers) GetState(
+	w http.ResponseWriter,
+	req bunrouter.Request,
+) error {
+	// fmt.Fprintf(os.Stderr, "GET /api/state\n")
+	c, err := self.upgrader.Upgrade(w, req.Request, nil)
+	if err != nil {
+		return middlewares.HTTPError{
+			StatusCode:  http.StatusInternalServerError,
+			Message:     "failed to upgrade websocket",
+			OriginError: err,
+		}
+	}
+	defer c.Close()
+
+	username, _, ok := req.BasicAuth()
+	if !ok {
+		return middlewares.HTTPError{
+			StatusCode: http.StatusBadRequest,
+			Message:    "username not exist",
+		}
+	}
+	dataCh := make(chan types.WordleState)
+	self.opCh <- &OperationSubs{
+		Username: username,
+		SubsCh:   &dataCh,
+	}
+
+	for data := range dataCh {
+		b, err := msgpack.Marshal(data)
+		if err != nil {
+			return middlewares.HTTPError{
+				StatusCode:  http.StatusInternalServerError,
+				Message:     "failed to marshal data into msgpack",
+				OriginError: err,
+			}
+		}
+		c.WriteMessage(websocket.BinaryMessage, b)
+	}
+
+	return utils.Success(w)
+}

handlers/wordle/handlers.go

@@ -0,0 +1,98 @@
+package wordle
+
+import (
+	"fmt"
+	"net/http"
+
+	"gitea.konchin.com/ytshih/inp2025/types"
+	"github.com/gorilla/websocket"
+)
+
+type Operation interface {
+	Run(self *Handlers) error
+}
+
+type OperationSubs struct {
+	Username string
+	SubsCh   *chan types.WordleState
+}
+
+func (op *OperationSubs) Run(self *Handlers) error {
+	_, ok := self.state.History[op.Username]
+	if !ok {
+		self.state.History[op.Username] = [types.GUESS_COUNT_LIMIT]types.Guess{}
+	}
+	// fmt.Fprintf(os.Stderr, "[DEBUG] %+v\n", self.state.History)
+	self.subs = append(self.subs, op.SubsCh)
+
+	return nil
+}
+
+type OperationGuess struct {
+	Username string `msgpack:"username"`
+	Guess    string `msgpack:"guess"`
+}
+
+func (op *OperationGuess) Run(self *Handlers) error {
+	self.state.CurrentGuess[op.Username] = op.Guess
+
+	if len(self.state.CurrentGuess) < len(self.state.History) {
+		return nil
+	}
+
+	for user, guess := range self.state.CurrentGuess {
+		if guess == self.ans {
+			self.state.GameEnd = true
+		}
+		guesses := self.state.History[user]
+		guesses[self.state.Round] = types.NewGuess(guess, self.ans)
+		self.state.History[user] = guesses
+	}
+	self.state.CurrentGuess = make(map[types.UsernameType]string)
+	self.state.Round++
+	if self.state.Round >= types.GUESS_COUNT_LIMIT {
+		self.state.GameEnd = true
+	}
+
+	return nil
+}
+
+type Handlers struct {
+	ans      string
+	state    types.WordleState
+	upgrader websocket.Upgrader
+	subs     []*chan types.WordleState
+
+	opCh chan Operation
+}
+
+func NewHandlers(ans string) *Handlers {
+	ret := &Handlers{
+		ans:   ans,
+		state: types.NewWordleState(),
+		upgrader: websocket.Upgrader{
+			ReadBufferSize:  1024,
+			WriteBufferSize: 1024,
+			CheckOrigin: func(r *http.Request) bool {
+				return true
+			},
+		},
+
+		opCh: make(chan Operation),
+	}
+	go ret.GameFlow()
+	return ret
+}
+
+func (self *Handlers) GameFlow() {
+	for op := range self.opCh {
+		if err := op.Run(self); err != nil {
+			panic(fmt.Errorf("game flow operation failed, %w", err))
+		}
+
+		// fmt.Fprintf(os.Stderr, "[DEBUG] %+v\n", self.state.History)
+		for _, ch := range self.subs {
+			*ch <- self.state
+		}
+	}
+}

handlers/wordle/postGuess.go

@@ -0,0 +1,54 @@
+package wordle
+
+import (
+	"io"
+	"net/http"
+
+	"gitea.konchin.com/ytshih/inp2025/middlewares"
+	"gitea.konchin.com/ytshih/inp2025/utils"
+	"github.com/uptrace/bunrouter"
+	"github.com/vmihailenco/msgpack/v5"
+)
+
+type PostGuessInput struct {
+	Guess string `msgpack:"guess"`
+}
+
+func (self *Handlers) PostGuess(
+	w http.ResponseWriter,
+	req bunrouter.Request,
+) error {
+	// fmt.Fprintf(os.Stderr, "POST /api/guess\n")
+	b, err := io.ReadAll(req.Body)
+	if err != nil {
+		return middlewares.HTTPError{
+			StatusCode:  http.StatusBadRequest,
+			Message:     "failed to read body payload",
+			OriginError: err,
+		}
+	}
+
+	var input PostGuessInput
+	if err := msgpack.Unmarshal(b, &input); err != nil {
+		return middlewares.HTTPError{
+			StatusCode:  http.StatusBadRequest,
+			Message:     "failed to unmarshal from msgpack",
+			OriginError: err,
+		}
+	}
+
+	username, _, ok := req.BasicAuth()
+	if !ok {
+		return middlewares.HTTPError{
+			StatusCode: http.StatusBadRequest,
+			Message:    "username not exist",
+		}
+	}
+
+	self.opCh <- &OperationGuess{
+		Username: username,
+		Guess:    input.Guess,
+	}
+
+	return utils.Success(w)
+}