package controllers

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

type AddPlayerInput struct {
	Name   string `json:"name" binding:"required"`
	ClanID uint   `json:"clan_id" binding:"required"`
}

type UpdatePlayerInput struct {
	Name   string `json:"name"`
	ClanID uint   `json:"clan_id"`
}

// GetAllPlayers GET /player
func GetAllPlayers(c *gin.Context) {
	var players []models.Player
	models.DB.Find(&players)

	c.JSON(http.StatusOK, players)
}

// GetPlayersByClanHTML GET /players_html
func GetPlayersByClanHTML(c *gin.Context) {
	var players []models.Player
	clanId := c.Request.URL.Query().Get("clan_id")
	if err := models.DB.
		Where("clan_id = ?", utils.StringToUint(clanId)).
		Find(&players).Error; err != nil {

		c.String(http.StatusBadRequest, "")
		log.Fatal(err)
		return
	}

	file, err := os.ReadFile("./templates/player_list_item.html")
	if err != nil {
		c.String(http.StatusBadRequest, "")
		log.Fatal(err)
		return
	}
	playerItem := string(file)

	game, err := GetActiveGame(c)
	if err != nil {
		c.String(http.StatusBadRequest, "")
		log.Fatal(err)
		return
	}

	var htmlOptions string
	for _, player := range players {
		var score string
		if val, err := cache.GetScore(player.ID, game.Tag); err != nil || val == -1.0 {
			score = "<i class=\"bi bi-dash me-2\" style=\"margin-left:0.7rem;\"></i>"
		} else {
			score = fmt.Sprintf("%.2f", val)
		}
		htmlOptions += fmt.Sprintf(playerItem, player.Name, score, utils.UintToString(player.ID)+"?game_tag="+game.Tag, player.ID, player.ID)
	}

	c.Header("Content-Type", "text/html")
	c.String(http.StatusOK, htmlOptions)
}

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

	var player models.Player
	if err := models.DB.Where("name = ?", input.Name).First(&player).Error; err == nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Player with this name already exists!"})
		return
	}

	player = models.Player{Name: input.Name, ClanID: input.ClanID}
	models.DB.Create(&player)

	c.JSON(http.StatusOK, player)

	_, err := fmt.Fprintf(utils.GinWriter, "Added player '"+player.Name+"'\n")
	if err != nil {
		log.Fatal(err)
	}
}

// GetPlayerByID GET /player/:id
func GetPlayerByID(c *gin.Context) {
	player := FindPlayerByID(utils.StringToUint(c.Param("id")))
	if player == nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Record not found!"})
		return
	}

	c.JSON(http.StatusOK, player)
}

// GetPlayerIDByName GET /playerid/:name
func GetPlayerIDByName(c *gin.Context) {
	var player models.Player

	if err := FindPlayerByName(&player, c).Error; err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Record not found!"})
		return
	}

	c.JSON(http.StatusOK, player.ID)
}

// UpdatePlayerByID PATCH /player/:id
func UpdatePlayerByID(c *gin.Context) {
	var input UpdatePlayerInput
	if err := c.ShouldBindJSON(&input); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	res := models.DB.Model(&models.Player{}).
		Where("id = ?", utils.StringToUint(c.Param("id"))).
		Updates(map[string]interface{}{
			"Name":   input.Name,
			"ClanID": input.ClanID,
		})
	if res.Error != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": res.Error.Error()})
		return
	}

	c.JSON(http.StatusOK, nil)

	_, err := fmt.Fprintf(utils.GinWriter, "Updated player '"+input.Name+"'\n")
	if err != nil {
		log.Fatal(err)
	}
}

// DeletePlayerByID DELETE /player/:id
func DeletePlayerByID(c *gin.Context) {
	player := FindPlayerByID(utils.StringToUint(c.Param("id")))
	if player == nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Record not found!"})
		return
	}

	models.DB.Delete(&player)

	c.JSON(http.StatusOK, true)

	_, err := fmt.Fprintf(utils.GinWriter, "Deleted player '"+player.Name+"'\n")
	if err != nil {
		log.Fatal(err)
	}
}

// DeleteAllPlayers DELETE /admin/player
func DeleteAllPlayers(c *gin.Context) {
	var players []models.Player
	if err := models.DB.
		Session(&gorm.Session{AllowGlobalUpdate: true}).
		Clauses(clause.Returning{}).
		Delete(&players).Error; err != nil {
		c.String(http.StatusBadRequest, "Purge failed! Error: "+err.Error())
		return
	}

	c.String(http.StatusOK, "Purged "+utils.UintToString(uint(len(players)))+" players!")
}

func FindPlayerByID(id uint) *models.Player {
	var res models.Player
	if err := models.DB.Where("id = ?", id).First(&res).Error; err != nil {
		return nil
	} else {
		return &res
	}
}

func FindPlayerByName(out interface{}, c *gin.Context) *gorm.DB {
	return models.DB.Where("name = ?", c.Param("name")).First(out)
}