tallytome/handler/tracker.go

package handler

import (
	"fmt"
	"math"
	"reflect"
	"strconv"

	"github.com/gofiber/fiber/v3"
	"github.com/gofiber/fiber/v3/log"
	"github.com/itsig0/tallytome/view/hptracker"
)

func Tracker(c fiber.Ctx) error {
	sess, err := store.Get(c)
	if err != nil {
		return err
	}

	hx := len(c.GetReqHeaders()["Hx-Request"]) > 0

	data := hptracker.TrackerData{
		HP:                  "0",
		HPBase:              "0",
		HPStartPercentage:   "0",
		HPPercentage:        "0",
		Mana:                "0",
		ManaBase:            "0",
		ManaRegen:           "0",
		ManaStartPercentage: "0",
		ManaPercentage:      "0",
	}

	fields := []string{"HP", "HPBase", "HPStartPercentage", "HPPercentage", "Mana", "ManaBase", "ManaRegen", "ManaStartPercentage", "ManaPercentage"}
	for _, field := range fields {
		if val := sess.Get("tracker_" + field); val != nil {
			reflect.ValueOf(&data).Elem().FieldByName(field).SetString(fmt.Sprint(val))
		}
	}

	return render(c, hptracker.Show(hx, data))
}

func TrackerUpdate(c fiber.Ctx) error {
	sess, err := store.Get(c)
	if err != nil {
		return err
	}

	data := hptracker.TrackerData{
		HP:                  c.FormValue("hp"),
		HPBase:              c.FormValue("hp"),
		HPStartPercentage:   "0",
		HPPercentage:        "100",
		Mana:                c.FormValue("mana"),
		ManaBase:            c.FormValue("mana"),
		ManaRegen:           c.FormValue("manaregen"),
		ManaStartPercentage: "0",
		ManaPercentage:      "100",
	}

	pre := "tracker_"
	sess.Set(pre+"HP", data.HP)
	sess.Set(pre+"HPBase", data.HPBase)
	sess.Set(pre+"HPPercentage", data.HPPercentage)
	sess.Set(pre+"HPStartPercentage", data.HPStartPercentage)

	sess.Set(pre+"Mana", data.Mana)
	sess.Set(pre+"ManaBase", data.ManaBase)
	sess.Set(pre+"ManaRegen", data.ManaRegen)
	sess.Set(pre+"ManaStartPercentage", data.ManaStartPercentage)
	sess.Set(pre+"ManaPercentage", data.ManaPercentage)

	sess.Save()

	return render(c, hptracker.TrackerColumn(data))
}

func TrackerDamage(c fiber.Ctx) error {
	sess, err := store.Get(c)
	if err != nil {
		return err
	}

	damage, err := strconv.Atoi(c.FormValue("damageInput"))
	if err != nil {
		c.Status(422)
		return c.SendString(err.Error())
	} else if damage <= 0 {
		c.Status(422)
		c.Append("HX-Retarget", "#damageInputs")
		return render(c, hptracker.Hp(hptracker.DamageData{
			Errors: "Darf nicht 0 oder kleiner sein.",
		}))
	}

	currentHP, err := strconv.Atoi(fmt.Sprint(sess.Get("tracker_HP")))
	if err != nil {
		c.Status(422)
		c.Append("HX-Retarget", "#damageInputs")
		return render(c, hptracker.Hp(hptracker.DamageData{
			Errors:      "Standard Werte nicht gesetzt.",
			Values:      c.FormValue("damageInput"),
			SavingThrow: c.FormValue("savingthrow"),
		}))
	}

	// no error handling here because it's already done for currentHP
	baseHP, _ := strconv.Atoi(fmt.Sprint(sess.Get("tracker_HPBase")))

	heal := string(c.FormValue("heal"))
	savingThrow := string(c.FormValue("savingthrow"))

	if savingThrow == "on" || heal == "false" {
		damageFloat := float64(damage) * 0.33333
		damage -= int(math.Round(damageFloat))
	}

	if heal == "true" {
		damage *= -1
	}

	newHP := currentHP - damage

	if newHP < 0 {
		newHP = 0
	}

	if newHP > baseHP {
		newHP = baseHP
	}

	newPercentage := (newHP * 100) / baseHP

	data := hptracker.TrackerData{
		HP:                fmt.Sprint(newHP),
		HPBase:            fmt.Sprint(sess.Get("tracker_HPBase")),
		HPStartPercentage: fmt.Sprint(sess.Get("tracker_HPPercentage")),
		HPPercentage:      fmt.Sprint(newPercentage),
	}

	sess.Set("tracker_HP", newHP)
	sess.Set("tracker_HPPercentage", newPercentage)

	sess.Save()

	c.Append("HX-Trigger", "HPUpdated")

	return render(c, hptracker.HPTracker(data))
}

func TrackerMana(c fiber.Ctx) error {
	sess, err := store.Get(c)
	if err != nil {
		return err
	}

	mana, err := strconv.Atoi(c.FormValue("manaInput"))
	if err != nil {
		c.Status(422)
		return c.SendString(err.Error())
	} else if mana <= 0 {
		c.Status(422)
		// c.Append("HX-Retarget", "#damageInputs")
		// return render(c, hptracker.Hp(hptracker.DamageData{
		// 	Errors: "Darf nicht 0 oder kleiner sein.",
		// }))
		return nil
	}

	currentMana, err := strconv.Atoi(fmt.Sprint(sess.Get("tracker_Mana")))
	if err != nil {
		c.Status(422)
		// c.Append("HX-Retarget", "#manaInputs")
		// return render(c, hptracker.Mana(hptracker.DamageData{
		// 	Errors: "Standard Werte nicht gesetzt.",
		// }))
		return err
	}

	baseMana, _ := strconv.Atoi(fmt.Sprint(sess.Get("tracker_ManaBase")))

	newMana := currentMana - mana

	newPercentage := (newMana * 100) / baseMana

	data := hptracker.TrackerData{
		Mana:                fmt.Sprint(newMana),
		ManaBase:            fmt.Sprint(sess.Get("tracker_ManaBase")),
		ManaStartPercentage: fmt.Sprint(sess.Get("tracker_ManaPercentage")),
		ManaPercentage:      fmt.Sprint(newPercentage),
	}

	sess.Set("tracker_Mana", newMana)
	sess.Set("tracker_ManaPercentage", newPercentage)

	sess.Save()

	return render(c, hptracker.ManaTracker(data))
}

func CheckStore(c fiber.Ctx) error {
	sess, err := store.Get(c)
	if err != nil {
		return err
	}
	log.Info(sess.Keys())
	return nil
}