package users

import (
	"encoding/json"
	"net/http"

	"git.acooldomain.co/server-manager/backend/auth"
	"git.acooldomain.co/server-manager/backend/dbhandler"
	"git.acooldomain.co/server-manager/backend/factories"
	"git.acooldomain.co/server-manager/backend/mail"
	"git.acooldomain.co/server-manager/backend/models"
	"github.com/gin-gonic/gin"
)

type UsersApi struct {
	userPassAuthHandler dbhandler.UserPassAuthanticationDbHandler
	tokenHandler        dbhandler.InviteTokenDbHandler
	mailClient          mail.MailClient
	config              *models.GlobalConfig
}

type UserResponse struct {
	Username    string            `json:"Username"`
	Nickname    string            `json:"nickname"`
	Email       string            `json:"Email"`
	Permissions models.Permission `json:"Permissions"`
}

func (con UsersApi) GetUsers(ctx *gin.Context) {
	users, err := con.userPassAuthHandler.ListUsers(ctx)

	if err != nil {
		ctx.AbortWithError(500, err)
		return
	}

	usersResponse := make([]UserResponse, len(users))
	for i, user := range users {
		usersResponse[i] = UserResponse{
			Username:    user.Username,
			Permissions: user.Permissions,
			Nickname:    user.Nickname,
			Email:       user.Email,
		}
	}

	ctx.JSON(http.StatusOK, usersResponse)
}

func (con UsersApi) GetUser(ctx *gin.Context) {
	claims, exists := ctx.Get("claims")
	if !exists {
		ctx.AbortWithStatus(403)
		return
	}

	ctx.IndentedJSON(http.StatusOK, UserResponse{
		Username:    claims.(*auth.AuthClaims).Username,
		Permissions: claims.(*auth.AuthClaims).Permissions,
	})
}

type InviteUser struct {
	Email       string            `json:"Email"`
	Permissions models.Permission `json:"Permissions"`
}

func (con UsersApi) InviteUser(ctx *gin.Context) {
	var request InviteUser
	json.NewDecoder(ctx.Request.Body).Decode(&request)

	token, err := con.tokenHandler.SaveInviteToken(ctx, request.Email, request.Permissions)

	if err != nil {
		ctx.AbortWithError(500, err)
		return
	}

	err = con.mailClient.SendMail(request.Email, "You've been invited to join", "please open this link https://games.acooldomain.co/signup?token="+token)
	if err != nil {
		ctx.AbortWithError(500, err)
		return
	}

	ctx.JSON(200, "OK")
}

type SetUserPermissionsRequest struct {
	Permissions models.Permission `json:"Permissions"`
}

func (con UsersApi) SetUserPermissions(ctx *gin.Context) {
	var request SetUserPermissionsRequest
	json.NewDecoder(ctx.Request.Body).Decode(&request)
	username := ctx.Param("user_id")

	err := con.userPassAuthHandler.SetPermissions(ctx, username, request.Permissions)
	if err != nil {
		ctx.AbortWithError(500, err)
		return
	}

	ctx.JSON(200, "OK")
}

func (con UsersApi) DeleteUser(ctx *gin.Context) {
	username := ctx.Param("user_id")

	err := con.userPassAuthHandler.RemoveUser(ctx, username)

	if err != nil {
		ctx.AbortWithError(500, err)
		return
	}

	ctx.JSON(200, "OK")
}

func LoadGroup(group *gin.RouterGroup, config models.GlobalConfig) {
	userAuthHandler, err := factories.GetUserPassAuthDbHandler(config.Authentication.UserPass)
	if err != nil {
		panic(err)
	}

	inviteHandler, err := factories.GetInviteTokenDbHandler(config.Authentication.UserPass.InviteTokenDatabase)

	mailClient := *mail.NewMailClient(config.Email)

	connection := UsersApi{
		userPassAuthHandler: userAuthHandler,
		tokenHandler:        inviteHandler,
		mailClient:          mailClient,
		config:              &config,
	}

	group.GET("", auth.AuthorizedTo(0), auth.AuthorizationEnforcer(), connection.GetUsers)
	group.GET("/@me", auth.AuthorizedTo(0), auth.AuthorizationEnforcer(), connection.GetUser)
	group.POST("", auth.AuthorizedTo(models.Admin), auth.AuthorizationEnforcer(), connection.InviteUser)
	group.DELETE("/:user_id", auth.AuthorizedTo(models.Admin), auth.AuthorizationEnforcer(), connection.DeleteUser)
	group.PATCH("/:user_id/permissions", auth.AuthorizedTo(models.Admin), auth.AuthorizationEnforcer(), connection.SetUserPermissions)
}