package controllers

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

type AddClanInput struct {
	Name        string `json:"name" binding:"required"`
	Tag         string `json:"tag" binding:"required"`
	KeepUpdated bool   `json:"keep_updated" gorm:"default:false"`
}

type UpdateClanInput struct {
	Name        string `json:"name" binding:"required"`
	Tag         string `json:"tag" binding:"required"`
	KeepUpdated bool   `json:"keep_updated" gorm:"default:false"`
}

// GetAllClans GET /clan
func GetAllClans(c *gin.Context) {
	var clans []models.Clan
	models.DB.Find(&clans)

	c.JSON(http.StatusOK, clans)
}

// GetAllClansHTML GET /clans_html
func GetAllClansHTML(c *gin.Context) {
	var clans []models.Clan
	models.DB.Find(&clans)

	var htmlOptions string
	htmlOptions = `<option disabled selected value>Auswählen...</option>`
	for _, clan := range clans {
		htmlOptions += fmt.Sprintf(`<option value="%d">[%s] %s</option>`, clan.ID, clan.Tag, clan.Name)
	}

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

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

	var clan models.Clan
	if err := FindClanByName(&clan, input.Name).Error; err == nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Clan with this name already exists!"})
		return
	} else if err := FindClanByTag(&clan, input.Tag).Error; err == nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Clan with this tag already exists!"})
		return
	}

	clan = models.Clan{Name: input.Name, Tag: input.Tag, KeepUpdated: input.KeepUpdated}
	models.DB.Create(&clan)

	c.JSON(http.StatusOK, clan)

	utils.Logger.Infof("Added clan '%s' with tag '%s'", clan.Name, clan.Tag)
}

// GetClanByID GET /clan/:id
func GetClanByID(c *gin.Context) {
	var clan models.Clan

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

	c.JSON(http.StatusOK, clan)
}

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

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

	c.JSON(http.StatusOK, nil)

	utils.Logger.Infof("Updated clan '%s' with tag '%s'", input.Name, input.Tag)
}

// DeleteClanByID DELETE /clan/:id
func DeleteClanByID(c *gin.Context) {
	var clan models.Clan
	if err := FindClanByID(&clan, c).Error; err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Record not found!"})
		return
	}

	models.DB.Delete(&clan)

	c.JSON(http.StatusOK, true)

	utils.Logger.Infof("Deleted clan '%s' with tag '%s'", clan.Name, clan.Tag)
}

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

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

func FindClanByName(out interface{}, name string) *gorm.DB {
	return models.DB.Where("name = ?", name).First(out)
}

func FindClanByTag(out interface{}, tag string) *gorm.DB {
	return models.DB.Where("tag = ?", tag).First(out)
}

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