package handlers

import (
	"errors"
	"fmt"
	"net/http"
	"strconv"

	"gitea.tecamino.com/paadi/access-handler/internal/utils"
	"gitea.tecamino.com/paadi/access-handler/models"
	"github.com/gin-gonic/gin"
)

func (aH *AccessHandler) AddUserTable() error {
	return aH.dbHandler.AddNewTable(models.User{})
}

func (aH *AccessHandler) AddDefaultUser() (err error) {
	// Create default settings for the new user
	settings := models.Settings{}
	aH.logger.Debug("AddDefaultUser", "set default quasar settings")
	settings.DefaultQuasarSettings()

	user := &models.User{
		Name:     "admin",
		Email:    "zuercher@tecamino.ch",
		Password: "$2a$10$sZZOWBP8DSFLrLFQNoXw8OsEEr0tez1B8lPzKCHofaHg6PMNxx1pG",
		Settings: settings,
	}

	// Check if a user with this email already exists
	if aH.dbHandler.Exists(&models.User{}, "email", user.Email, false) {
		aH.logger.Debug("AddDefaultUser", "user email "+user.Email+" exists already")
		// Found a user → skip create
		return nil
	}

	// Insert default admin user into the database

	if err := aH.dbHandler.AddNewColum(user); err != nil {
		return err
	}

	role := &models.Role{}
	if err := aH.dbHandler.GetByKey(role, "", "role", "admin", false); err != nil {
		return err
	}
	return aH.dbHandler.AddRelation(user, role, "Role")
}

func (aH *AccessHandler) AddUser(c *gin.Context) {
	var user models.User
	err := c.BindJSON(&user)
	if err != nil {
		aH.logger.Error("AddUser", err)
		c.JSON(http.StatusInternalServerError, models.NewJsonErrorResponse(err))
		return
	}

	if !user.IsValid() {
		aH.logger.Error("AddUser", "user empty")
		c.JSON(http.StatusBadRequest, models.NewJsonMessageResponse("user empty"))
		return
	}

	// Check if a user with this email already exists
	if aH.dbHandler.Exists(&models.User{}, "email", user.Email, false) {
		// Found a user → skip create
		aH.logger.Error("AddUser", "user with email "+user.Email+" already exists")
		c.JSON(http.StatusBadRequest, models.NewJsonMessageResponse(fmt.Sprintf("user with email %s already exists", user.Email)))
		return
	}

	if !utils.IsValidEmail(user.Email) {
		aH.logger.Error("AddUser", "not valid email address")
		c.JSON(http.StatusBadRequest, models.NewJsonErrorResponse(errors.New("not valid email address")))
		return
	}

	// Hash the provided password before saving
	user.Password, err = utils.HashPassword(user.Password)
	if err != nil {
		aH.logger.Error("AddUser", err)
		c.JSON(http.StatusInternalServerError, nil)
		return
	}

	aH.logger.Debug("AddUser", "add default quasar user setting ")
	user.Settings.DefaultQuasarSettings()

	aH.logger.Debug("AddUser", "add new user "+user.Name+" with role "+user.Role.Role)

	if user.Role.Id != 0 {
		if err := aH.dbHandler.GetById(&user.Role, "", user.Role.Id); err != nil {
			aH.logger.Error("AddUser", err)
			c.JSON(http.StatusInternalServerError, nil)
			return
		}
	} else {
		if err := aH.dbHandler.GetByKey(&user.Role, "", "role", user.Role.Role, false); err != nil {
			aH.logger.Error("AddUser", err)
			c.JSON(http.StatusInternalServerError, nil)
			return
		}
	}
	user.RoleID = &user.Role.Id

	// Insert the new user record
	if err := aH.dbHandler.AddNewColum(&user); err != nil {
		aH.logger.Error("AddUser", err)
		c.JSON(http.StatusInternalServerError, nil)
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"message": fmt.Sprintf("user '%s' successfully added", user.Name),
	})
}

func (aH *AccessHandler) ChangePassword(c *gin.Context) {
	var user models.User
	err := c.BindJSON(&user)
	if err != nil {
		aH.logger.Error("ChangePassword", err)
		c.JSON(http.StatusInternalServerError, models.NewJsonErrorResponse(err))
		return
	}

	// get user to check ChangePassword
	var dbRecord models.User
	err = aH.dbHandler.GetById(&dbRecord, "Role", user.Id)
	if err != nil {
		aH.logger.Error("ChangePassword", err)
		c.JSON(http.StatusInternalServerError, nil)
		return
	}

	// Check if old password is correct
	if !utils.CheckPassword(user.Password, dbRecord.Password) {
		// Found a user → skip create
		aH.logger.Error("ChangePassword", "wrong password entered for user: "+user.Name)
		c.JSON(http.StatusBadRequest, models.NewJsonMessageResponse("invalid credentials"))
		return
	}

	// Hash the provided password before saving
	user.Password, err = utils.HashPassword(user.NewPassword)
	if err != nil {
		aH.logger.Error("ChangePassword", err)
		c.JSON(http.StatusInternalServerError, nil)
		return
	}

	aH.logger.Debug("ChangePassword", "change user "+user.Name+" password")

	// Update user
	aH.dbHandler.UpdateValuesById(&user, "Role", user.Id)

	c.JSON(http.StatusOK, gin.H{
		"message": fmt.Sprintf("password of user '%s' changed", user.Name),
	})
}

func (aH *AccessHandler) GetUser(c *gin.Context) {
	var i int
	var err error

	id := c.Query("id")
	if id == "undefined" || id == "null" || id == "" {
		i = 0
	} else {
		i, err = strconv.Atoi(id)
		if err != nil {
			aH.logger.Error("GetUser", err)
			c.JSON(http.StatusInternalServerError, nil)
			return
		}
	}

	var users []models.User
	err = aH.dbHandler.GetById(&users, "Role", uint(i))
	if err != nil {
		aH.logger.Error("GetUser", err)
		c.JSON(http.StatusInternalServerError, nil)
		return
	}
	c.JSON(http.StatusOK, users)
}

func (aH *AccessHandler) UpdateUser(c *gin.Context) {
	var user models.User
	if err := c.BindJSON(&user); err != nil {
		aH.logger.Error("UpdateUser", err)
		c.JSON(http.StatusInternalServerError, nil)
		return
	}
	err := aH.dbHandler.UpdateValuesById(&user, "Role", user.Id)
	if err != nil {
		aH.logger.Error("UpdateUser", err)
		c.JSON(http.StatusInternalServerError, nil)
		return
	}
	c.JSON(http.StatusOK, models.NewJsonMessageResponse("successfully updated user '"+user.Email+"'"))
}

func (aH *AccessHandler) DeleteUser(c *gin.Context) {
	queryId := c.Query("id")

	if queryId == "" || queryId == "null" || queryId == "undefined" {
		aH.logger.Error("DeleteUser", "id query missing or wrong value: "+queryId)
		c.JSON(http.StatusBadRequest, gin.H{
			"message": "id query missing or wrong value: " + queryId,
		})
		return
	}

	var request struct {
		Ids []int `json:"ids"`
	}

	err := c.BindJSON(&request)
	if err != nil {
		aH.logger.Error("DeleteUser", err)
		c.JSON(http.StatusInternalServerError, nil)
		return
	}

	if len(request.Ids) == 0 {
		aH.logger.Error("DeleteUser", "no ids given to be deleted")
		c.JSON(http.StatusBadRequest, gin.H{
			"message": "no ids given to be deleted",
		})
		return
	}

	var ownId string
	removeIds := make([]uint, len(request.Ids))
	for i, id := range request.Ids {
		if queryId == fmt.Sprint(id) {
			ownId = queryId
			continue
		}
		removeIds[i] = uint(id)
	}

	if ownId != "" {
		aH.logger.Error("DeleteUser", "can not delete logged in member id: "+queryId)
		c.JSON(http.StatusBadRequest, gin.H{
			"message": "can not delete logged in member id: " + queryId,
			"id":      queryId,
		})
		return
	}

	err = aH.dbHandler.DeleteById(&models.User{}, removeIds...)
	if err != nil {
		aH.logger.Error("DeleteUser", err)
		c.JSON(http.StatusInternalServerError, nil)
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"message": "member(s) deleted",
	})
}