package handler

import (
	"mchess_server/api"
	"mchess_server/chess"
	"mchess_server/lobbies"
	"mchess_server/utils"
	"net/http"
	"sync"

	"github.com/gin-gonic/gin"
	"github.com/google/uuid"
	"go.uber.org/ratelimit"
)

var mut sync.Mutex
var limiter = ratelimit.New(10)

func HostGameHandler(c *gin.Context) {
	limiter.Take()

	player := chess.NewPlayer(uuid.New())
	u := lobbies.GetUsher()

	mut.Lock()
	defer mut.Unlock()
	lobby := u.CreateNewPrivateLobby(player)
	u.AddPlayerToLobbyAndStartGameIfFull(player, lobby)

	passphrase := lobby.Passphrase.String()
	info := api.PlayerInfo{
		PlayerID:   &player.Uuid,
		Passphrase: &passphrase,
	}
	c.Header("Access-Control-Allow-Origin", "*")
	c.IndentedJSON(http.StatusOK, info)
}

func GetLobbyForPassphraseHandler(c *gin.Context) {
	limiter.Take()

	reqPassphrase := c.Param("phrase")
	if reqPassphrase == "" {
		c.IndentedJSON(http.StatusBadRequest, reqPassphrase)
		return
	}

	passPhraseWithSpaces := utils.ConvertToPassphraseWithSpaces(reqPassphrase)
	lobby := lobbies.GetLobbyRegistry().GetLobbyByPassphrase(passPhraseWithSpaces)

	if lobby == nil {
		c.IndentedJSON(http.StatusNotFound, reqPassphrase)
		return
	}

	passphrase := api.Passphrase{
		Value: (*string)(&lobby.Passphrase),
	}

	c.Header("Access-Control-Allow-Origin", "*")
	c.IndentedJSON(http.StatusOK, passphrase)
}

func JoinPrivateGame(c *gin.Context) {
	limiter.Take()

	req := api.PlayerInfo{}
	err := c.ShouldBindJSON(&req)
	if err != nil || req.Passphrase == nil || *req.Passphrase == "" {
		c.IndentedJSON(http.StatusNotFound, req)
		return
	}

	u := lobbies.GetUsher()

	if req.PlayerID != nil { //is reconnect
		lobby := u.FindExistingPrivateLobby(utils.Passphrase(*req.Passphrase))
		var found bool
		if lobby != nil {
			_, found = lobby.GetPlayerByUUID(*req.PlayerID)
		}
		if found {
			c.Header("Access-Control-Allow-Origin", "*")
			c.IndentedJSON(
				http.StatusOK,
				api.PlayerInfo{
					PlayerID:   req.PlayerID,
					Passphrase: req.Passphrase,
				})
			return
		} else {
			c.IndentedJSON(http.StatusNotFound, req)
			return
		}
	}

	player := chess.NewPlayer(uuid.New())

	mut.Lock()
	defer mut.Unlock()
	lobby := u.FindExistingPrivateLobby(utils.Passphrase(*req.Passphrase))
	if lobby != nil {
		u.AddPlayerToLobbyAndStartGameIfFull(player, lobby)
	} else {
		c.IndentedJSON(http.StatusNotFound, req)
		return
	}

	info := api.PlayerInfo{
		PlayerID:   &player.Uuid,
		Passphrase: req.Passphrase,
	}
	c.Header("Access-Control-Allow-Origin", "*")
	c.IndentedJSON(http.StatusOK, info)
}

func JoinGameHandler(c *gin.Context) {
	limiter.Take()

	passphrase := api.Passphrase{}
	err := c.ShouldBindJSON(&passphrase)
	if err != nil {
		c.IndentedJSON(http.StatusBadRequest, nil)
		return
	}

	u := lobbies.GetUsher()
	lobby := u.FindExistingPrivateLobby(utils.Passphrase(*passphrase.Value))
	if lobby == nil {
		c.IndentedJSON(http.StatusNotFound, nil)
		return
	}

	lobbyInfo := api.Passphrase{
		Value: (*string)(&lobby.Passphrase),
	}

	c.IndentedJSON(http.StatusOK, lobbyInfo)
}