// NewGame returns a pointer to a game instance given two connections
func NewGame(initiator *connection.Conn, name string) *Game {
	id := uuid.NewV4().String()
	serverlog.General("Initiating Game:", id, "with", initiator.Identification())
	return &Game{
		ID:        id,
		Name:      name,
		Initiator: initiator,
		InitTime:  time.Now(),
		Ready:     false,
		UDSPath:   path.Join("~", ".pppsrv", "sockets", id+".sock"),
		FinChan:   make(chan bool, 1),
	}
}

// RequestGameList handles the case where a player sends a RequestGameList message
func RequestGameList(conn *connection.Conn, allGames map[string]*games.Game, message messages.RequestGameListMessage) {
	serverlog.General("Received RequestGameList message from", conn.Identification())

	if !conn.Registered {
		serverlog.General("Unregistered", conn.Identification(), "called RequestGameList")
		return
	}

	serverlog.General("Sending Game list to", conn.Identification())
	gameList := games.NewGameListMessage(allGames)
	conn.Write(gameList.Bytes())
}

// LeaveGame handles the case where a player sends a LeaveGame message
func LeaveGame(conn *connection.Conn, allGames map[string]*games.Game, message messages.LeaveGameMessage) {
	serverlog.General("Received LeaveGame message from", conn.Identification())

	if !conn.Registered {
		serverlog.General("Unregistered", conn.Identification(), "called LeaveGame")
		return
	}

	if !conn.InGame {
		serverlog.General(conn.Identification(), "attempted to leave a game but isn't in a game:", allGames[conn.GameID].Name)
		return
	}

	if allGames[conn.GameID].Ready {
		// will be dealt with by game object
		return
	}

	conn.InGame = false
	delete(allGames, conn.GameID)
}

// Start will start the game
func (g *Game) Start(player2 *connection.Conn) {
	serverlog.General("Starting", g.Identification(), "with player 2", player2.Identification())
	g.Player2 = player2
	g.Ready = true
	g.startUDS()
}

// RequestAlias handles the situation when a client sends a RequestAlias message
func RequestAlias(message messages.RequestAliasMessage, conn *connection.Conn, al map[string]bool) {
	serverlog.General("Received RequestAlias message from", conn.Identification())

	if conn.Registered {
		serverlog.General(conn.Identification(), "attempted to request new alias:", message.Alias)
		denied := messages.NewAliasDeniedMessage("Already registered with alias: " + conn.Alias)
		conn.Write(denied.Bytes())
		return
	}
	if _, ok := al[message.Alias]; ok {
		serverlog.General(conn.Identification(), "requested existing alias:", message.Alias)
		denied := messages.NewAliasDeniedMessage("That alias is taken")
		conn.Write(denied.Bytes())
		return
	}
	if len(message.Alias) < 3 || len(message.Alias) > 10 {
		serverlog.General(conn.Identification(), "requested too long or too short alias:", message.Alias)
		denied := messages.NewAliasDeniedMessage("An alias needs to be between 3 and 10 characters long (inclusive)")
		conn.Write(denied.Bytes())
		return
	}

	serverlog.General("Successful registration under alias:", message.Alias)
	conn.Alias = message.Alias
	conn.Registered = true

	serverlog.General("Adding:", message.Alias, "to takenAliases map")
	al[message.Alias] = true

	approved := messages.NewAliasApprovedMessage()
	conn.Write(approved.Bytes())
}

// JoinGame handles the case where a player sends a JoinGame message
func JoinGame(conn *connection.Conn, allGames map[string]*games.Game, message messages.JoinGameMessage) {
	serverlog.General("Received JoinGame message from conn:", conn.Alias)

	if !conn.Registered {
		serverlog.General("Unregistered", conn.Identification, "called JoinGame")
		denied := messages.NewJoinGameDeniedMessage("You have not registered an Alias")
		conn.Write(denied.Bytes())
		return
	}

	if conn.InGame {
		serverlog.General(conn.Identification(), "attempted to join a game but is already in game:", allGames[conn.GameID].Name)
		denied := messages.NewJoinGameDeniedMessage("You re already in a game")
		conn.Write(denied.Bytes())
		return
	}

	if _, ok := allGames[message.GameID]; !ok {
		serverlog.General(conn.Identification(), "attempted to join a non existing game:", message.GameID)
		denied := messages.NewJoinGameDeniedMessage("No games with that ID")
		conn.Write(denied.Bytes())
		return
	}

	game := allGames[message.GameID]
	serverlog.General(conn.Identification(), "Successfully joined", game.Identification())
	conn.InGame = true
	conn.GameID = game.ID
	game.Start(conn)
	go listenFinished(game, allGames)
}

// CreateGame handles the case where a player sends a CreateGame message
func CreateGame(conn *connection.Conn, allGames map[string]*games.Game, message messages.CreateGameMessage) {
	serverlog.General("Received CreateGame message from", conn.Identification())

	if !conn.Registered {
		serverlog.General("Unregistered", conn.Identification(), "called createGame")
		denied := messages.NewCreateGameDeniedMessage(message.GameName, "You are not registered")
		conn.Write(denied.Bytes())
		return
	}

	if conn.InGame {
		serverlog.General(conn.Identification(), "tried to create a new game but is already in game:", allGames[conn.GameID].Name)
		denied := messages.NewCreateGameDeniedMessage(message.GameName, "You are already in a game")
		conn.Write(denied.Bytes())
		return
	}

	serverlog.General("Creating game:", message.GameName, "by", conn.Identification())
	game := games.NewGame(conn, message.GameName)
	serverlog.General(conn.Identification(), "setting InGame to true and Game to the game:", game.Name)
	conn.InGame = true
	conn.GameID = game.ID
	serverlog.General("Attatching", game.Identification(), "to games list")
	allGames[game.ID] = game

	approved := messages.NewCreateGameApprovedMessage(game.ID, game.Name)
	conn.Write(approved.Bytes())
}