golias/handlers/elements.go

package handlers

import (
	"errors"
	"golias/llmapi"
	"golias/models"
	"html/template"
	"net/http"
)

func HandleShowCreateForm(w http.ResponseWriter, r *http.Request) {
	show := true
	tmpl, err := template.ParseGlob("components/*.html")
	if err != nil {
		abortWithError(w, err.Error())
		return
	}
	if err := tmpl.ExecuteTemplate(w, "createform", show); err != nil {
		log.Error("failed to execute createform template", "error", err)
	}
}

func HandleHideCreateForm(w http.ResponseWriter, r *http.Request) {
	show := false
	tmpl, err := template.ParseGlob("components/*.html")
	if err != nil {
		abortWithError(w, err.Error())
		return
	}
	if err := tmpl.ExecuteTemplate(w, "createform", show); err != nil {
		log.Error("failed to execute createform template", "error", err)
	}
}

func HandleShowColor(w http.ResponseWriter, r *http.Request) {
	word := r.URL.Query().Get("word")
	ctx := r.Context()
	tmpl, err := template.ParseGlob("components/*.html")
	if err != nil {
		abortWithError(w, err.Error())
		return
	}
	fi, err := getFullInfoByCtx(ctx)
	if err != nil {
		abortWithError(w, err.Error())
		return
	}
	if fi.State.Role != "guesser" {
		err = errors.New("need to be guesser to open the card")
		abortWithError(w, err.Error())
		return
	}
	// whos move it is?
	if fi.State.Team != models.UserTeam(fi.Room.TeamTurn) {
		err = errors.New("not your team's move")
		abortWithError(w, err.Error())
		return
	}
	if !fi.Room.MimeDone {
		abortWithError(w, "wait for the clue")
		return
	}
	color, exists := fi.Room.WCMap[word]
	log.Debug("got show-color request", "word", word, "color", color)
	if !exists {
		abortWithError(w, "word is not found")
		return
	}
	cardword := models.WordCard{
		Word:     word,
		Color:    color,
		Revealed: true,
	}
	fi.Room.RevealSpecificWord(word)
	fi.Room.UpdateCounter()
	action := models.Action{
		Actor:      fi.State.Username,
		ActorColor: string(fi.State.Team),
		WordColor:  string(color),
		Action:     "guessed",
		Word:       word,
	}
	fi.Room.ActionHistory = append(fi.Room.ActionHistory, action)
	// if opened card is of color of opp team, change turn
	oppositeColor := fi.Room.GetOppositeTeamColor()
	switch string(color) {
	case "black":
		// game over
		fi.Room.IsRunning = false
		fi.Room.IsOver = true
		fi.Room.TeamWon = oppositeColor
	case "white", string(oppositeColor):
		// end turn
		fi.Room.TeamTurn = oppositeColor
	}
	// check if no cards left => game over
	if fi.Room.BlueCounter == 0 {
		// blue won
		fi.Room.IsRunning = false
		fi.Room.IsOver = true
		fi.Room.TeamWon = "blue"
	}
	if fi.Room.RedCounter == 0 {
		// red won
		fi.Room.IsRunning = false
		fi.Room.IsOver = true
		fi.Room.TeamWon = "red"
	}
	if err := saveFullInfo(fi); err != nil {
		abortWithError(w, err.Error())
		return
	}
	notify(models.NotifyRoomUpdatePrefix+fi.Room.ID, "")
	if err := tmpl.ExecuteTemplate(w, "cardword", cardword); err != nil {
		log.Error("failed to execute cardword template", "error", err)
	}
}

func HandleActionHistory(w http.ResponseWriter, r *http.Request) {
	fi, err := getFullInfoByCtx(r.Context())
	if err != nil {
		abortWithError(w, err.Error())
		return
	}
	tmpl, err := template.ParseGlob("components/*.html")
	if err != nil {
		abortWithError(w, err.Error())
		return
	}
	if err := tmpl.ExecuteTemplate(w, "actionhistory", fi.Room.ActionHistory); err != nil {
		log.Error("failed to execute actionhistory template", "error", err)
	}
}

func HandleAddBot(w http.ResponseWriter, r *http.Request) {
	// get team; // get role; make up a name
	team := r.URL.Query().Get("team")
	role := r.URL.Query().Get("role")
	fi, err := getFullInfoByCtx(r.Context())
	if err != nil {
		abortWithError(w, err.Error())
		return
	}
	bot, err := llmapi.NewBot(role, team, "bot1", fi.Room.ID, cfg)
	if err != nil {
		abortWithError(w, err.Error())
		return
	}
	bot.StartBot()
	notify(models.NotifyRoomUpdatePrefix+fi.Room.ID, "")
}