package controllers

import (
	"InfantrySkillCalculator/models"
	"InfantrySkillCalculator/utils"
	"fmt"
	"github.com/gin-gonic/gin"
	"internal/cache"
	"log"
	"net/http"
)

type AddCacheInput struct {
	PlayerID uint    `json:"player_id" binding:"required"`
	Score    float32 `json:"score" gorm:"default:-1.0"`
	GameTag  string  `json:"game_tag" binding:"required"`
}

type UpdateCacheInput struct {
	Score float32 `json:"score" gorm:"default:-1.0"`
}

// GetCacheByPlayerID GET /cache/:player_id?game_tag=TAG
func GetCacheByPlayerID(c *gin.Context) {
	playerId := utils.StringToUint(c.Param("player_id"))
	gameTag := c.Request.URL.Query().Get("game_tag")

	val, err := cache.GetScore(playerId, gameTag)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Record not found!"})
	} else {
		c.JSON(http.StatusOK, val)
	}
}

// AddCache POST /cache
func AddCache(c *gin.Context) {
	var input AddCacheInput
	if err := c.BindJSON(&input); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	var game models.Game
	if err := FindGameByTag(&game, input.GameTag).Error; err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Game not found!"})
		return
	}

	err := cache.SetScore(input.PlayerID, input.GameTag, input.Score)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Cache update failed! Error: " + err.Error()})
		return
	}

	c.JSON(http.StatusOK, nil)
}

// UpdateCacheByPlayerID PATCH /cache/:id?game=TAG
func UpdateCacheByPlayerID(c *gin.Context) {
	playerID := utils.StringToUint(c.Param("id"))
	gameTag := c.Request.URL.Query().Get("game")
	score := utils.StringToFloat(c.PostForm("score"))

	err := cache.SetScore(playerID, gameTag, score)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Cache update failed! Error: " + err.Error()})
	} else {
		c.JSON(http.StatusOK, nil)
	}
}

// DeleteCacheByPlayerID DELETE /cache/:id?game=TAG
func DeleteCacheByPlayerID(c *gin.Context) {
	playerID := utils.StringToUint(c.Param("id"))
	gameTag := c.Request.URL.Query().Get("game")

	if err := cache.DeleteScore(playerID, gameTag); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
	} else {
		c.JSON(http.StatusOK, nil)
	}
}

// DeleteAllCaches DELETE /cache
func DeleteAllCaches(c *gin.Context) {
	if err := cache.PurgeCache(); err != nil {
		c.String(http.StatusBadRequest, err.Error())
	} else {
		c.String(http.StatusOK, "Purged all caches!")
	}
}

// GetScoreByPlayerID GET /score/:player_id?game_tag=TAG
func GetScoreByPlayerID(c *gin.Context) {
	var player models.Player
	var gameTag = c.Request.URL.Query().Get("game_tag")
	var playerId = utils.StringToUint(c.Param("player_id"))
	if err := models.DB.
		Model(&models.Player{}).
		Where("id = ?", playerId).
		First(&player).Error; err != nil {

		c.JSON(http.StatusBadRequest, gin.H{"error": "Player not found!"})
		return
	}

	score, err := cache.GetScore(player.ID, gameTag)
	if err != nil || score == -1 {
		score = utils.CalcPlayerScore(player.Name, gameTag)
		if score == score && score != -1 { // not NaN
			if err := cache.SetScore(player.ID, gameTag, score); err != nil {
				log.Fatal(err)
			}
		}
	}

	if score != score || score == -1 { // NaN
		c.String(http.StatusOK, "<i class=\"bi bi-person-x-fill me-2 text-danger fs-5\" style=\"margin-left: 0.69rem;\"></i>")
	} else if score != -1 {
		c.String(http.StatusOK, fmt.Sprintf("%.2f", score))
	} else {
		c.JSON(http.StatusBadRequest, "Invalid request!")
	}
}