package controllers

import (
	"InfantrySkillCalculator/models"
	"InfantrySkillCalculator/utils"
	"github.com/gin-gonic/gin"
	"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
func GetCacheByPlayerID(c *gin.Context) {
	playerId := utils.StringToUint(c.Param("player_id"))

	game, err := GetActiveGame(c)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "No active game available!"})
		return
	}

	val, err := models.PlayerCache.GetScore(playerId, game.Tag)
	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 := models.PlayerCache.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 := models.PlayerCache.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 := models.PlayerCache.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 := models.PlayerCache.PurgeCache(); err != nil {
		c.String(http.StatusBadRequest, err.Error())
	} else {
		c.String(http.StatusOK, "Purged all caches!")
	}
}

func UpdateCacheAfterExpiry(key string) {
	utils.Logger.Println("[KeepUpdated] Cache expired: " + key)

	playerId, err := models.PlayerCache.GetPlayerIdFromCacheKey(key)
	if err != nil {
		utils.Logger.Fatal(err)
	}

	var player models.Player
	if err := models.DB.
		Preload("Clan").
		Where("id = ?", playerId).
		First(&player).Error; err != nil {

		utils.Logger.Println("Failed to find player: " + err.Error())
	}

	if player.Clan.KeepUpdated {
		score := CalcPlayerScore(player.Name, "BF2042")
		if score == score && score != -1 { // not NaN
			if err := models.PlayerCache.SetScore(player.ID, "BF2042", score); err != nil {
				utils.Logger.Println("Failed to update cache: " + err.Error())
			} else {
				utils.Logger.Println("[KeepUpdated] Updated cache for player " + player.Name)
			}
		} else {
			utils.Logger.Println("[KeepUpdated] Received NaN for player " + player.Name)
		}
	}
}