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
	if err := models.DB.Find(&clans).Error; err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Record not found!"})
		utils.Logger.Errorf("[CLAN] Error while getting all clans: %s", err.Error())
		return
	}

	c.JSON(http.StatusOK, clans)
}

// GetAllClansHTML GET /clans_html
func GetAllClansHTML(c *gin.Context) {
	var clans []models.Clan
	if err := models.DB.Find(&clans).Error; err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Record not found!"})
		utils.Logger.Errorf("[CLAN] Error while getting all clans: %s", err.Error())
		return
	}

	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
	var clan models.Clan

	if err := c.BindJSON(&input); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		utils.Logger.Errorf("[CLAN] Error while binding JSON: %s", err.Error())
		return
	}

	clan = models.Clan{Name: input.Name, Tag: input.Tag, KeepUpdated: input.KeepUpdated}

	if err := models.DB.Create(&clan).Error; err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		utils.Logger.Errorf("[CLAN] Error while adding clan '[%s] %s': %s", input.Tag, input.Name, err.Error())
		return
	}

	c.JSON(http.StatusOK, clan)

	utils.Logger.Infof("[CLAN] Added clan: [%s] %s", clan.Tag, clan.Name)
}

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

	if err := models.DB.Where("id = ?", c.Param("id")).First(&clan).Error; err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Record not found!"})
		utils.Logger.Errorf("[CLAN] Error while getting clan by ID: %s", err.Error())
		return
	}

	c.JSON(http.StatusOK, clan)
}

// UpdateClanByID PATCH /clan/:id
func UpdateClanByID(c *gin.Context) {
	var input UpdateClanInput
	var clan models.Clan

	if err := c.ShouldBindJSON(&input); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		utils.Logger.Errorf("[CLAN] Error while binding JSON: %s", err.Error())
		return
	}

	if err := models.DB.First(&clan, c.Param("id")).Error; err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Record not found!"})
		utils.Logger.Errorf("[CLAN] Error while getting clan by ID: %s", err.Error())
		return
	}

	oldValues := models.Clan{
		Name:        clan.Name,
		Tag:         clan.Tag,
		KeepUpdated: clan.KeepUpdated,
	}

	clan.Name = input.Name
	clan.Tag = input.Tag
	clan.KeepUpdated = input.KeepUpdated

	if err := models.DB.Save(&clan).Error; err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		utils.Logger.Errorf("[CLAN] Error while updating clan '%s': %s", input.Name, err.Error())
		return
	}

	c.JSON(http.StatusOK, nil)

	utils.Logger.Infof("[CLAN] Updated clan: [%s] %s -> [%s] %s", oldValues.Tag, oldValues.Name, clan.Tag, clan.Name)
}

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

	if err := models.DB.Clauses(clause.Returning{}).
		Where("id = ?", c.Param("id")).
		Delete(&clan).Error; err != nil {

		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		utils.Logger.Errorf("[CLAN] Error while deleting clan '%s': %s", clan.Name, err.Error())
		return
	}

	c.JSON(http.StatusOK, true)

	utils.Logger.Infof("[CLAN] Deleted clan: [%s] %s", clan.Tag, clan.Name)
}

// 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())
		utils.Logger.Errorf("[CLAN] Error while purging all clans: %s", err.Error())
		return
	}

	c.String(http.StatusOK, "Purged "+utils.UintToString(uint(len(clans)))+" clans!")
	utils.Logger.Infof("[CLAN] Purged %d clans!", len(clans))
}