package controllers

import (
	"fmt"
	"html"
	"log"
	"net/http"
	"smt/models"
	"strings"

	"github.com/gin-gonic/gin"
)

type GroupInput struct {
	GroupId   int    `db:"GroupId" json:"groupId"`
	GroupName string `db:"GroupName" json:"groupName"`
	LdapGroup bool   `db:"LdapGroup" json:"ldapGroup"`
	LdapDn    string `db:"LdapDn" json:"ldapDn"`
	Admin     bool   `db:"Admin" json:"admin"`
}

func GetGroupsHandler(c *gin.Context) {
	groups, err := models.GroupList()

	if err != nil {
		errString := fmt.Sprintf("error retrieving groups : '%s'", err)
		log.Printf("GetGroups %s\n", errString)
		c.JSON(http.StatusBadRequest, gin.H{"error": errString})
		return
	}

	c.JSON(http.StatusOK, gin.H{"message": "success", "data": groups})
}

func AddGroupHandler(c *gin.Context) {
	var input GroupInput

	if err := c.ShouldBindJSON(&input); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	if len(input.GroupName) == 0 {
		c.JSON(http.StatusBadRequest, gin.H{"error": "no group name specified"})
		return
	}

	if input.LdapGroup && len(input.LdapDn) == 0 {
		c.JSON(http.StatusBadRequest, gin.H{"error": "ldapGroup is true but no ldapDn specified"})
		return
	}

	g := models.Group{}
	g.GroupName = input.GroupName
	g.LdapGroup = input.LdapGroup
	g.LdapDn = input.LdapDn
	g.Admin = input.Admin

	//remove leading/trailing spaces in groupname
	g.GroupName = html.EscapeString(strings.TrimSpace(g.GroupName))

	// Check if role already exists
	testGroup, _ := models.GroupGetByName(g.GroupName)
	log.Printf("AddGroup checking if group '%s' already exists\n", g.GroupName)

	if (models.Group{} == testGroup) {
		log.Printf("AddGroup confirmed no existing group name\n")
	} else {
		errorString := fmt.Sprintf("attempt to register conflicting groupname '%s'", g.GroupName)
		log.Printf("Register error : '%s'\n", errorString)
		c.JSON(http.StatusBadRequest, gin.H{"error": errorString})
		return
	}

	_, err := g.GroupAdd()

	if err != nil {
		errString := fmt.Sprintf("error creating group : '%s'", err)
		log.Printf("AddGroup %s\n", errString)
		c.JSON(http.StatusBadRequest, gin.H{"error": errString})
		return
	}

	c.JSON(http.StatusOK, gin.H{"message": "group creation success", "data": g})
}

func DeleteGroupHandler(c *gin.Context) {
	var input GroupInput

	if err := c.ShouldBindJSON(&input); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	// Input validation
	if input.GroupId == 0 && len(input.GroupName) == 0 {
		c.JSON(http.StatusBadRequest, gin.H{"error": "no group name or id specified"})
		return
	}

	g := models.Group{}
	g.GroupId = input.GroupId
	g.GroupName = input.GroupName

	//remove leading/trailing spaces in groupname
	g.GroupName = html.EscapeString(strings.TrimSpace(g.GroupName))

	// Confirm group exists
	testGroup, _ := models.GroupGetByName(g.GroupName)
	log.Printf("DeleteGroupHandler confirming group '%s' exists\n", g.GroupName)
	if (models.Group{} == testGroup) {
		errString := fmt.Sprintf("attempt to delete non-existing group '%s'", g.GroupName)
		log.Printf("DeleteGroupHandler %s\n", errString)
		c.JSON(http.StatusBadRequest, gin.H{"error": errString})
		return
	} else {
		err := g.GroupDelete()

		if err != nil {
			errString := fmt.Sprintf("error deleting group : '%s'", err)
			log.Printf("DeleteGroupHandler %s\n", errString)
			c.JSON(http.StatusBadRequest, gin.H{"error": errString})
			return
		}

		c.JSON(http.StatusOK, gin.H{"message": "group deletion success"})
	}
}