pugbot.py

# Pickup Game Bot for use with discord
# Modified by: Alex Laswell for use with Fortress Forever
# Based on:
# 	PugBot-for-Discord by techlover1 https://github.com/techlover1/PugBot-for-Discord

import asyncio
import config
from collections import OrderedDict
import datetime
from datetime import timedelta
import discord
from discord import Game
from discord.ext.commands import Bot
from os import system
import pymongo
from pymongo.collection import ReturnDocument
import random
from random import choice, shuffle
import re
import requests
import subprocess
import time
import valve.rcon

# Configurable constants
adminChannelID = config.adminChannelID
adminRoleID = config.adminRoleID
adminRoleMention = config.adminRoleMention
bannedChannelID = config.bannedChannelID
blueteamChannelID = config.blueteamChannelID
cmdprefix = config.cmdprefix
dbtoken = config.dbtoken
discordServerID = config.discordServerID
durationOfCheckin = config.durationOfCheckin
durationOfMapVote = config.durationOfMapVote
durationOfReadyUp = config.durationOfReadyUp
durationOfVeto = config.durationOfVeto
flaskServerURL = config.flaskServerURL
newPlayerRoleID = config.newPlayerRoleID
newPlayerRoleStr = config.newPlayerRoleStr
numRestarts = 0
playerRoleID = config.playerRoleID
poolRoleID = config.poolRoleID
probationRoleID = config.probationRoleID
quotes = config.quotes
readyupChannelID = config.readyupChannelID
redteamChannelID = config.redteamChannelID
requestChannelID = config.requestChannelID
rconPW = config.rconPW
server_address = config.server_address
serverID = config.serverID
serverIDRegEx = config.serverIDRegEx
serverPattern = config.serverPattern
serverPW = config.serverPW
singleChannelID = config.singleChannelID
sizeOfGame = config.sizeOfGame
sizeOfTeams = config.sizeOfTeams
sizeOfMapPool = config.sizeOfMapPool
sizeOfRecentMap = config.sizeOfRecentMap
timeoutRoleID = config.timeoutRoleID
token = config.token
vipPlayerID = config.vipPlayerID
websiteKey = config.websiteKey
websiteURL = config.websiteURL

# Globals
BLUE_TEAM = []
CHOSEN_MAP = []
LAST_BLUE_TEAM = []
LAST_MAP = []
LAST_RED_TEAM = []
LAST_TIME = time.time()
MAP_PICKS = {}
PLAYERS = []
RED_TEAM = []
START_TIME = time.time()
STARTER = []
PICKUP_RUNNING = False
RANDOM_TEAMS = False
VOTE_FOR_MAPS = True

# the bot, client, and server objects
Bot = Bot(command_prefix=cmdprefix)
client = discord.Client()
server = None
adminRole = None
accessRole = None
newPlayerRole = None
poolRole = None
probationRole = None
timeoutRole = None

# create the MongoDB client and connect to the database
dbclient = pymongo.MongoClient(dbtoken)
database = dbclient.FortressForever

# a valve RCON (Remote CONnection)
rcon = valve.rcon.RCON(server_address, rconPW)
rcon.connect()
rcon.authenticate()

#
# Functions A-Z
#


# do not allow commands if the author is in a timeout
async def author_is_in_timeout(message):
    global server
    member = server.get_member(message.author.id)
    if timeoutRoleID in [r.id for r in member.roles]:
        if message.content.startswith(cmdprefix):
            emb = discord.Embed(
                description="I'm sorry, you cannot use any of these commands while you are in timeout. You will need to speak with a "
                + adminRoleMention
                + " for further details.",
                colour=0xFF0000,
            )
            emb.set_author(name=Bot.user.name, icon_url=Bot.user.avatar_url)
            await message.author.send(embed=emb)
        return True
    return False


# Select the BLUE_TEAM
async def blue_team_picks(caps, context, playerPool):
    global BLUE_TEAM, RED_TEAM, PLAYERS, server
    playerPicked = False
    await send_emb_message_to_channel(
        0x00FF00,
        caps[0].mention
        + " type @player to pick. Available players are:\n\n"
        + "\n".join([p.mention for p in playerPool]),
        context,
    )

    while not playerPicked:
        # check for a pick and catch it if they don't mention an available player
        try:

            def check(msg):
                return msg.author == server.get_member(caps[0].id)

            inputobj = await Bot.wait_for("message", check=check)
            picked = inputobj.mentions[0]

            # If the player is in players and they are not already picked, add to the team
            if picked in PLAYERS:
                if picked not in RED_TEAM and picked not in BLUE_TEAM:
                    BLUE_TEAM.append(picked)
                    try:
                        playerPool.remove(picked)
                    except ValueError:
                        pass  # 'picked' is not in playerPool, so just move on
                    playerPicked = True
                    await send_emb_message_to_channel_blue(
                        picked.mention + " has been added to the team", context
                    )
                else:
                    await send_emb_message_to_channel(
                        0xFF0000, picked.mention + " is already on a team", context
                    )
            else:
                await send_emb_message_to_channel(
                    0xFF0000, picked.mention + " is not in this pickup", context
                )
        except (IndexError):
            pass


# check that the admin who started the game is still here
async def check_for_afk_admin():
    global adminRoleID, cmdprefix, STARTER
    # check for advanced filtering
    def check(msg):
        if adminRoleID in [r.id for r in msg.author.roles]:
            return msg.content.startswith(cmdprefix + "here")

    inputobj = None
    try:
        inputobj = await Bot.wait_for("message", timeout=durationOfCheckin, check=check)
    except Exception:
        pass
    # returns 'None' if asyncio.TimeoutError thrown
    if inputobj != None:  # game_starter did !checkin
        if inputobj.author != STARTER[0]:
            # another admin has stepped in
            STARTER = []
            STARTER.append(inputobj.author)
        return True
    else:  # game_starter did not !checkin
        return False


# cycle through the all the players in the pool and verify they are ready
async def check_for_afk_players():
    global PLAYERS, readyupChannelID, server
    ready_channel = discord.utils.get(server.channels, id=readyupChannelID)
    ready_users = ready_channel.members
    afk_players = []

    # only preform this check if the readyupChannelID is a valid voice channel
    if ready_channel is not None:
        # check to verify if each player is in the ready-up channel
        for p in PLAYERS:
            if p not in ready_users:
                afk_players.append(p)  # add to missing players list
    return afk_players


async def check_for_map_nominations(context):
    global cmdprefix, MAP_PICKS, sizeOfGame, sizeOfMapPool, PICKUP_RUNNING, PLAYERS
    while (
        len(MAP_PICKS) < sizeOfMapPool and PICKUP_RUNNING and len(PLAYERS) == sizeOfGame
    ):
        # need to build the list of maps
        mapStr = ""
        for k in MAP_PICKS:
            mapStr = mapStr + str(MAP_PICKS[k]) + " (" + k.mention + ")\n"
        await send_emb_message_to_channel(
            0xFF0000,
            "Players must nominate more maps before we can proceed\nCurrently Nominated Maps ("
            + str(len(MAP_PICKS))
            + "/"
            + str(sizeOfMapPool)
            + ")\n"
            + mapStr,
            context,
        )

        async def needMapPicks(msg):
            # check function for advanced filtering
            def check(msg):
                return msg.content.startswith(cmdprefix + "nominate")

            # wait until someone nominates another map
            try:
                await Bot.wait_for("message", timeout=30, check=check)
            except Exception:
                pass

        await needMapPicks(context.message)


# allows the game_starter to veto admin commands
async def check_for_veto(command, context):
    global cmdprefix, STARTER
    # generic check to allow game_starter to !veto another admin's command
    await send_emb_message_to_channel(
        0xFF0000,
        STARTER[0].mention
        + "\n\n"
        + context.author.mention
        + " is trying to "
        + command
        + " your pickup. You have "
        + str(durationOfVeto)
        + " seconds to "
        + cmdprefix
        + "veto them, or the command will happen",
        context,
    )
    # check for advanced filtering
    def check(msg):
        return msg.author == STARTER[0] and msg.content.lower().startswith(
            cmdprefix + "veto"
        )

    inputobj = None
    try:
        inputobj = await Bot.wait_for("message", timeout=durationOfVeto, check=check)
    except Exception:
        pass
    if inputobj != None:  # game_starter did !veto the command
        return True
    else:  # game_starter did not !veto
        return False


# Check to see if the message has been sent via a Direct Message to the bot
async def command_is_in_wrong_channel(context):
    global requestChannelID, singleChannelID
    if context.command.name == "pug":
        if context.channel.id != requestChannelID:
            # Bot only listens to the request channel when granting access
            await send_emb_message_to_channel(
                0xFF0000,
                context.author.mention
                + " you cannot use this command in this channel. Retry inside the "
                + server.get_channel(requestChannelID).name
                + " channel",
                context,
            )
            return True
        else:
            return False
    elif context.command.name == "addserver" or context.command.name == "delserver":
        # Bot only listens to these commands via direct message
        if context.message.guild is not None:
            await send_emb_message_to_channel(
                0xFF0000,
                context.author.mention
                + " this command will only work as a direct message to the bot",
                context,
            )
            return True
        else:
            return False
    elif (
        context.command.name == "ban"
        or context.command.name == "permaban"
        or context.command.name == "unban"
    ):
        # Admin channel commands
        if (
            context.channel.id != adminChannelID
            and context.channel.id != bannedChannelID
            and context.channel.id != singleChannelID
        ):
            # Bot will only listen to the above channels when banning or unbanning players
            await send_emb_message_to_user(
                0xFF0000,
                "I'm sorry, you cannot use that command in the "
                + context.channel.name
                + " channel. Retry inside the "
                + server.get_channel(adminChannelID).name
                + ", "
                + server.get_channel(bannedChannelID).name
                + ", or the "
                + server.get_channel(singleChannelID).name
                + " channel",
                context,
            )
            return True
        else:
            return False
    elif context.channel.id != singleChannelID:
        # Bot only listens to one channel for all other commands
        await send_emb_message_to_channel(
            0xFF0000,
            context.author.mention
            + " you cannot use this command in this channel. Retry inside the "
            + server.get_channel(singleChannelID).name
            + " channel",
            context,
        )
        return True
    return False


async def command_will_fubar_server(command):
    if command == "exit":
        return True
    elif command == "quit":
        return True
    elif command == "test":
        return True
    else:
        return False


async def count_votes_message_channel(tdelta, keys, context, votelist, votetotals):
    global sizeOfMapPool
    tmpstr = ""
    # reset totals
    votetotals = []
    [votetotals.append(0) for x in range(sizeOfMapPool)]
    # tally the buckets
    for k, v in votelist.items():
        votetotals[v - 1] += 1
    # zip with keys to make a nice dict
    totals = OrderedDict(zip(keys, votetotals))
    for x, y in totals.items():
        tmpstr = tmpstr + str(x) + " : " + str(y) + "\n"
    # set up the remaining time to vote timedelta
    tdelta0 = tdelta - timedelta(microseconds=tdelta.microseconds)
    await send_emb_message_to_channel(
        0x00FF00,
        tmpstr
        + "\n"
        + str(durationOfMapVote - tdelta0.total_seconds())
        + " seconds remaining",
        context,
    )


async def go_go_gadget_pickup(context):
    global adminRole, BLUE_TEAM, CHOSEN_MAP, cmdprefix, durationOfReadyUp, MAP_PICKS, server, sizeOfGame, STARTER, PICKUP_RUNNING, PLAYERS, poolRole, poolRoleID, RANDOM_TEAMS, RED_TEAM, rcon, readyupChannelID, server_address, rconPW, VOTE_FOR_MAPS
    afk_players = []
    BLUE_TEAM = []
    caps = []
    RED_TEAM = []
    playerPool = []
    playerPoolStr = ""
    counter = 0
    countdown = time.time()
    elapsedtime = time.time() - countdown
    inputobj = 0  # used to manipulate the objects from messages
    pick_captains_counter = 0
    ready_channel = discord.utils.get(context.guild.channels, id=readyupChannelID)
    RANDOM_TEAMS = (
        True
    )  # if game starter does not change, will pick teams randomly from players list
    td = timedelta(seconds=elapsedtime)

    await send_emb_message_to_channel(
        0x00FF00,
        "The pickup is starting!!\n\n"
        + poolRole.mention
        + " join the "
        + ready_channel.name
        + " channel to signify you are present and ready",
        context,
    )

    # set up the embedded message in-case we need to message players
    emb = discord.Embed(
        title="The pickup is starting!!\n\nJoin the "
        + ready_channel.name
        + " channel to signify you are present and ready",
        colour=0xFF0000,
    )
    emb.set_author(name=Bot.user.name, icon_url=Bot.user.avatar_url)
    # give the players time to ready-up
    while td.total_seconds() < durationOfReadyUp:
        # only check every 5 seconds
        await asyncio.sleep(5)
        # loop through the channel and check to see if everyone has joined it or not
        afk_players = await check_for_afk_players()
        if len(afk_players) > 0:
            afkstr = "\n".join([p.mention for p in afk_players])
            elapsedtime = time.time() - countdown
            td = timedelta(seconds=elapsedtime)
            # only message everyone on every third iteration
            if (counter % 3) == 0:
                await send_emb_message_to_channel(
                    0xFF0000, "Missing players:\n\n" + afkstr + "\nPlease join the " + ready_channel.name, context
                )
                for p in afk_players:
                    try:
                        await p.send(embed=emb)
                    except Exception:
                        pass
            counter += 1
        else:
            # all players in list are idle in channel and ready
            break

    # if afk_players has people in it, then those player(s) timed out
    if len(afk_players) > 0:
        for idleUser in afk_players:
            PLAYERS.remove(idleUser)  # remove from players list
            MAP_PICKS.pop(
                idleUser, None
            )  # remove this players nomination if they had one
            try:
                await idleUser.remove_roles(poolRole)
            except Exception:
                pass
            await send_emb_message_to_channel(
                0xFF0000,
                idleUser.mention
                + " has been removed from the pickup due to inactivity",
                context,
            )
            await Bot.change_presence(
                activity=discord.Game(
                    name="Pickup ("
                    + str(len(PLAYERS))
                    + "/"
                    + str(sizeOfGame)
                    + ") "
                    + cmdprefix
                    + "add"
                )
            )
        return False  # break out if we remove a player

    await send_emb_message_to_channel(
        0x00FF00, "All players are confirmed ready!", context
    )

    # Verifying admin status if they have not already confirmed ready
    if STARTER[0] not in PLAYERS:
        await send_emb_message_to_channel(
            0xFFA500,
            "Verifying that we have an admin\n\n"
            + STARTER[0].mention
            + " please reply with "
            + cmdprefix
            + "here so we can proceed",
            context,
        )
        adminPresent = False
        while not adminPresent:
            adminPresent = await check_for_afk_admin()
            if not adminPresent:
                # do we have an admin in the pool we can give the pickup to
                for p in PLAYERS:
                    if await user_has_access(p):
                        # admin found : transferring pickup
                        await send_emb_message_to_channel(
                            0xFF0000,
                            STARTER[0].mention
                            + " seems to be missing\n\nTransferring the game to "
                            + p.mention,
                            context,
                        )
                        STARTER = []
                        STARTER.append(p)
                        adminPresent = True
                        break  # no need to find another admin
                if not adminPresent:
                    # try to private message the game_starter
                    emb = discord.Embed(
                        description="You did not reply with "
                        + cmdprefix
                        + "here and your pickup has been put on hold",
                        colour=0xFF0000,
                    )
                    emb.set_author(name=Bot.user.name, icon_url=Bot.user.avatar_url)
                    await STARTER[0].send(embed=emb)
                    # ping all admins to see if someone can take over
                    await send_emb_message_to_channel(
                        0xFF0000,
                        adminRole.mention
                        + " the admin who started this pickup seems to be missing. "
                        + cmdprefix
                        + "here and save the pickup",
                        context,
                    )
    # adminPresent == True

    #
    # Begin the pickup
    #

    # Map Selection
    await Bot.change_presence(activity=discord.Game(name="Map Selection"))

    if len(CHOSEN_MAP) > 0:
        await verify_chosen_map_is_good(context)

    # do we have the right amount of map nominations
    if len(CHOSEN_MAP) == 0:
        await check_for_map_nominations(context)

    if not await pickup_is_full(context):
        return False  # exit go_go if someone has removed

    if len(CHOSEN_MAP) == 0:
        await pick_map(context)

    if not await pickup_is_full(context):
        return False  # exit go_go if someone has removed

    # by having the game admin approve
    # we can make sure teams end up fair more often
    adminApproves = False
    while not adminApproves:
        # loop until the game starter makes a decision
        pick_captains_counter = (
            1
        )  # tracks how many times the game_starter has been asked
        shuffle(PLAYERS)  # shuffle the player pool
        RANDOM_TEAMS = await pick_captains(caps, context)
        while len(caps) < 2:
            if len(PLAYERS) < sizeOfGame:
                if len(PLAYERS) > 0:
                    # game is no longer full
                    await send_emb_message_to_channel(
                        0xFF0000, "ABORTING: The pickup is no longer full", context
                    )
                    await Bot.change_presence(
                        activity=discord.Game(
                            name="Pickup ("
                            + str(len(PLAYERS))
                            + "/"
                            + str(sizeOfGame)
                            + ") "
                            + cmdprefix
                            + "add"
                        )
                    )
                    return False
                else:
                    # game has been !ended
                    await Bot.change_presence(activity=discord.Game(name=" "))
                    return True
            elif pick_captains_counter > 2:
                # game_starter is afk ... pug will be ended
                await send_emb_message_to_channel(
                    0xFF0000,
                    "This pickup has been abandoned by the admin and will now be ended\n\n"
                    + adminRole.mention
                    + " someone who is here, will need to start a new one",
                    context,
                )
                await Bot.change_presence(activity=discord.Game(name=" "))
                return True
            else:
                RANDOM_TEAMS = await pick_captains(caps, context)
                pick_captains_counter += 1

        if not await pickup_is_full(context):
            return False  # exit go_go if someone has removed

        # set up the initial teams
        if RANDOM_TEAMS:
            for i in range(0, sizeOfTeams):
                RED_TEAM.append(PLAYERS[i])
                BLUE_TEAM.append(PLAYERS[i + sizeOfTeams])
        else:
            # only add the captains if not already added
            # cmdprefix + manual already adds 'captains' to teams
            in_team = False
            for p in BLUE_TEAM:
                if p in caps:
                    in_team = True
            if not in_team:
                BLUE_TEAM.append(caps[0])
            in_team = False
            for p in RED_TEAM:
                if p in caps:
                    in_team = True
            if not in_team:
                RED_TEAM.append(caps[1])

            # copy the player pool over
            for p in PLAYERS:
                if p not in caps:
                    playerPool.append(p)

        # Switch off picking until the teams are all full
        await Bot.change_presence(activity=discord.Game(name="Team Selection"))

        # if teams are not already full:
        if len(RED_TEAM) < sizeOfTeams and len(BLUE_TEAM) < sizeOfTeams:
            if not await pickup_is_full(context):
                return False  # exit go_go if someone has removed

            await send_emb_message_to_channel(
                0x00FF00, caps[0].mention + " vs " + caps[1].mention, context
            )
            # Blue captain picks first
            await blue_team_picks(caps, context, playerPool)
            if len(playerPool) > 1:
                # only make the captain pick if they have a choice
                await red_team_picks(caps, context, playerPool)
            else:
                RED_TEAM.append(playerPool[0])
                await send_emb_message_to_channel_red(
                    playerPool[0].mention + " has been added to the team", context
                )
            while len(RED_TEAM) < sizeOfTeams and len(BLUE_TEAM) < sizeOfTeams:
                if not await pickup_is_full(context):
                    return False  # exit go_go if someone has removed

                # Red captain gets two picks first round so start with red
                await red_team_picks(caps, context, playerPool)

                if not await pickup_is_full(context):
                    return False  # exit go_go if someone has removed

                if len(playerPool) > 1:
                    # only make the captain pick if they have a choice
                    await blue_team_picks(caps, context, playerPool)
                else:
                    BLUE_TEAM.append(playerPool[0])
                    await send_emb_message_to_channel_blue(
                        playerPool[0].mention + " has been added to the team", context
                    )
        # both teams are full
        # verify everything looks good
        await send_emb_message_to_channel_blue(
            "\n".join([p.mention for p in BLUE_TEAM]), context
        )  # Blue Team information
        await send_emb_message_to_channel_red(
            "\n".join([p.mention for p in RED_TEAM]), context
        )  # Red Team information
        await send_emb_message_to_channel(
            0xFFA500,
            STARTER[0].mention
            + " these are the teams\n\nMap selection: "
            + CHOSEN_MAP
            + "\n\nReply with "
            + cmdprefix
            + "accept to accept them or with "
            + cmdprefix
            + "repick and we can choose again",
            context,
        )
        didChoose = False
        while not didChoose:
            # check for advanced filtering
            def check(msg):
                if msg.author == STARTER[0]:
                    if msg.content.startswith(
                        cmdprefix + "accept"
                    ) or msg.content.startswith(cmdprefix + "repick"):
                        return True
                return False

            inputobj = None
            try:
                inputobj = await Bot.wait_for(
                    "message", timeout=durationOfCheckin, check=check
                )
            except Exception:
                pass
            # returns 'None' if asyncio.TimeoutError thrown
            if inputobj != None:
                didChoose = True
                # switch on choice
                if inputobj.content.startswith(cmdprefix + "accept"):
                    adminApproves = True
                elif inputobj.content.startswith(cmdprefix + "repick"):
                    # reset so we can pick new teams
                    caps = []
                    BLUE_TEAM = []
                    playerPool = []
                    RED_TEAM = []
                    adminApproves = False
            else:
                didChoose = False
                await send_emb_message_to_channel(
                    0xFF0000,
                    STARTER[0].mention
                    + " please make a selection:\n\n"
                    + cmdprefix
                    + "accept to **accept** the teams\n\n"
                    + cmdprefix
                    + "repick to discard these teams and **repick** new ones",
                    context,
                )
    # adminApproves and everything is set

    # pm users and message server with game information
    await send_information(context)

    # change the map in the server to the chosen map
    try:
        rcon = valve.rcon.RCON(server_address, rconPW)
        rcon.connect()
        rcon.authenticate()
        resp = rcon.execute("changelevel " + CHOSEN_MAP)
        print(
            "LOG MESSAGE: RCON command <changelevel "
            + CHOSEN_MAP
            + "> response received\n\t"
            + str(resp)
            + "\nAt time "
            + time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
        )
    except Exception as inst:
        print(inst)
        pass

    # move the players to their respective voice channels
    for p in RED_TEAM:
        try:
            await p.edit(voice_channel=Bot.get_channel(redteamChannelID))
        except (ValueError, HTTPException, Forbidden):
            continue
    for p in BLUE_TEAM:
        try:
            await p.edit(voice_channel=Bot.get_channel(blueteamChannelID))
        except (ValueError, HTTPException, Forbidden):
            continue

    # Save all the information for !last
    await save_last_game_info()

    # Build the list of players for the website
    for i in range(sizeOfTeams):
        playerPoolStr += BLUE_TEAM[i].name + ","
        playerPoolStr += RED_TEAM[i].name + ","
    playerPoolStr = playerPoolStr[:-1]  # delete the last comma

    # POST to the information to the website
    await post_to_website(playerPoolStr)

    # remove the players from the pool
    await remove_everyone_from_pool_role(context)
    return True


# Lists all of the maps in the MongoDB table : maps
async def list_all_the_maps(msg):
    global database
    # find will return all documents in the maps collection
    foundmaps = database.maps.find({})
    # convert to a list so we can index into it
    maps = list(foundmaps)

    # with the aliases, this message gets big quickly so we
    # need to chunk up the maplist into sections to accommodate
    emb = discord.Embed(
        description="Currently, you may nominate any of the following maps:",
        colour=0xFFA500,
    )
    emb.set_author(name=Bot.user.name, icon_url=Bot.user.avatar_url)

    # print the maps in groups of 20
    iCount = 0
    for map in maps:
        if iCount % 20 == 0:
            await msg.author.send(embed=emb)
            emb = discord.Embed(description="", colour=0xFFA500)
            emb.set_author(name=Bot.user.name, icon_url=Bot.user.avatar_url)
        emb.add_field(name=str(map["name"]), value=str(map["aliases"]), inline=False)
        iCount += 1
    await msg.author.send(embed=emb)


# Check if the map was played in the last few pickups
async def map_was_recently_played(mapname):
    global database, sizeOfRecentMap
    iCount = 0
    pugs = database.pickups.find({})
    pugs.sort( "_id", pymongo.DESCENDING )
    for pug in pugs:
        if iCount >= sizeOfRecentMap:
            return False
        if pug["map"] == mapname:
            return True
        iCount += 1


# Check to see if the map nominated is an alias
async def mapname_is_valid(mpname):
    # access the global vars
    global database
    # check in name
    cursor = database.maps.find(
        {"$or": [{"name": mpname}, {"name": "ff_" + mpname}, {"aliases": mpname}]}
    )
    for map in cursor:
        return map["name"]
    # did not find mapname
    return "INVALID"


# wait until the game starter makes a decision
async def pick_captains(caps, context):
    global BLUE_TEAM, cmdprefix, PLAYERS, RED_TEAM, sizeOfTeams, STARTER
    bcap = Bot.user.name
    rcap = Bot.user.name
    # set presence
    await Bot.change_presence(activity=discord.Game(name="Selecting Captains"))

    # human readable Usage message to channel
    emb = discord.Embed(
        description=STARTER[0].mention + " please select one of the options below",
        colour=0xFFA500,
    )
    emb.set_author(name=Bot.user.name, icon_url=Bot.user.avatar_url)
    emb.add_field(
        name=cmdprefix + "captains",
        value="to manually select the captains",
        inline=False,
    )
    emb.add_field(
        name=cmdprefix + "manual", value="to manually select both teams", inline=False
    )
    emb.add_field(
        name=cmdprefix + "randcapts", value="to randomize the captains. Provide a list of two or more users to narrow the pool of choices. e.g. @p1 @p2 @p3\nIf no players are provided, captains are picked from the entire pool.", inline=False
    )
    emb.add_field(
        name=cmdprefix + "shuffle", value="to randomize the teams", inline=False
    )
    await context.channel.send(embed=emb)

    # check function for advance filtering
    def check(msg):
        if msg.author == STARTER[0]:
            if msg.content.startswith(cmdprefix + "captains"):
                return True
            elif msg.content.startswith(cmdprefix + "manual"):
                return True
            elif msg.content.startswith(cmdprefix + "randcapts"):
                return True
            elif msg.content.startswith(cmdprefix + "shuffle"):
                return True
        return False

    # wait up to two (2) minutes for the game starter to make a decision
    inputobj = None
    try:
        inputobj = await Bot.wait_for("message", timeout=120, check=check)
    except Exception:
        pass
    # returns 'None' if asyncio.TimeoutError thrown
    if inputobj != None:
        # switch on choice
        if inputobj.content.startswith(cmdprefix + "captains"):
            # msg.mentions returns an unordered list
            # therefore we have to get each name individually
            # this way the admin has control over who is blue and red
            plyrStr = "\n".join([p.mention for p in PLAYERS])
            await send_emb_message_to_channel_blue(
                STARTER[0].mention
                + " pick the blue team captain using @playername in your reply. Available players are:\n\n"
                + plyrStr,
                context,
            )
            while bcap == Bot.user.name:
                try:
                    # try to get the user the admin has specified
                    def check(msg):
                        return msg.author == STARTER[0]

                    inputobj = None
                    try:
                        inputobj = await Bot.wait_for(
                            "message", timeout=60, check=check
                        )
                    except Exception:
                        pass
                    if inputobj != None:
                        bcap = inputobj.mentions[0]
                        if bcap not in PLAYERS:
                            await send_emb_message_to_channel(
                                0xFF0000,
                                STARTER[0].mention
                                + " player must be added to the pickup. Available players are:\n\n"
                                + plyrStr,
                                context,
                            )
                            bcap = Bot.user.name
                    else:  # timeout
                        await send_emb_message_to_channel_blue(
                            STARTER[0].mention
                            + " pick the blue team captain using @playername in your reply. Available players are:\n\n"
                            + plyrStr,
                            context,
                        )
                except (IndexError):
                    # keep trying if they did not mention someone
                    await send_emb_message_to_channel_blue(
                        STARTER[0].mention
                        + " pick the blue team captain using @playername in your reply. Available players are:\n\n"
                        + plyrStr,
                        context,
                    )
            # do the same for red team
            temp = []  # list for players
            for p in PLAYERS:
                if p != bcap:
                    temp.append(p)
            plyrStr = "\n".join([p.mention for p in temp])
            await send_emb_message_to_channel_red(
                STARTER[0].mention
                + " pick the red team captain using @playername in your reply. Available players are:\n\n"
                + plyrStr,
                context,
            )
            while rcap == Bot.user.name:
                try:
                    # try to get the user the admin has specified
                    def check(msg):
                        return msg.author == STARTER[0]

                    inputobj = None
                    try:
                        inputobj = await Bot.wait_for(
                            "message", timeout=60, check=check
                        )
                    except Exception:
                        pass
                    if inputobj != None:
                        rcap = inputobj.mentions[0]
                        if rcap not in PLAYERS:
                            await send_emb_message_to_channel(
                                0xFF0000,
                                STARTER[0].mention
                                + " player must be added to the pickup. Available players are:\n\n"
                                + plyrStr,
                                context,
                            )
                            rcap = Bot.user.name
                    else:  # timeout
                        await send_emb_message_to_channel_red(
                            STARTER[0].mention
                            + " pick the red team captain using @playername in your reply. Available players are:\n\n"
                            + plyrStr,
                            context,
                        )
                except (IndexError):
                    # keep trying if they did not mention someone
                    await send_emb_message_to_channel_red(
                        STARTER[0].mention
                        + " pick the red team captain using @playername in your reply. Available players are:\n\n"
                        + plyrStr,
                        context,
                    )
            if bcap == rcap:
                await send_emb_message_to_channel(
                    0xFF0000,
                    STARTER[0].mention
                    + " you cannot pick the same captain for both teams",
                    context,
                )
                return False
            else:
                caps.append(bcap)
                caps.append(rcap)
                return False
        if inputobj.content.startswith(cmdprefix + "manual"):
            plyrStr = ""
            # do the picking here so that teams are full before we leave this function
            while len(BLUE_TEAM) != sizeOfTeams:
                plyrStr = ""
                for p in PLAYERS:
                    if p not in BLUE_TEAM:
                        plyrStr += p.mention
                        plyrStr += "\n"
                await send_emb_message_to_channel_blue(
                    STARTER[0].mention
                    + " pick the players for the blue team using "
                    + cmdprefix
                    + "blue <@playername>, <@playername>, ... , <@playername> in your reply.\n\nAvailable players are:\n\n"
                    + plyrStr
                    + "\n\n**Current players** are: "
                    + "\n".join([p.mention for p in BLUE_TEAM]),
                    context,
                )

                # check function for advance filtering
                def check(msg):
                    return msg.author == STARTER[0] and msg.content.startswith(
                        cmdprefix + "blue "
                    )

                # try to get the users the admin has specified
                inputobj = None
                try:
                    inputobj = await Bot.wait_for("message", timeout=60, check=check)
                except Exception:
                    pass
                if inputobj != None:
                    for p in inputobj.mentions:
                        if p not in PLAYERS:
                            await send_emb_message_to_channel(
                                0xFF0000,
                                p.mention
                                + " is not added to the pickup."
                                + STARTER[0].mention
                                + " you will need to pick someone else",
                                context,
                            )
                        else:
                            BLUE_TEAM.append(p)
                    if len(BLUE_TEAM) < sizeOfTeams:
                        # not enough players in blueTeam
                        await send_emb_message_to_channel(
                            0xFF0000,
                            STARTER[0].mention
                            + " this team is not full, you will need to pick "
                            + str(sizeOfTeams - len(BLUE_TEAM))
                            + " more players",
                            context,
                        )
                    elif len(BLUE_TEAM) > sizeOfTeams:
                        # too many players in blueTeam
                        # loop until we have the right number
                        while len(BLUE_TEAM) != sizeOfTeams:
                            if len(BLUE_TEAM) < sizeOfTeams:
                                # admin took too many players off
                                # break and let outter loop handle this case
                                break
                            await send_emb_message_to_channel(
                                0xFF0000,
                                STARTER[0].mention
                                + " this team has too many players. Pick player(s) to take off using "
                                + cmdprefix
                                + "takeoff <@playername>, <@playername>, ... , <@playername>\n\nCurrent players are:\n\n"
                                + "\n".join([p.mention for p in BLUE_TEAM]),
                                context,
                            )
                            # loop until the admin has specified someone
                            didRemove = False
                            while not didRemove:
                                # check for advanced filtering
                                def check(msg):
                                    return msg.author == STARTER[
                                        0
                                    ] and msg.content.startswith(cmdprefix + "takeoff")

                                inputobj = None
                                try:
                                    inputobj = await Bot.wait_for(
                                        "message", timeout=60, check=check
                                    )
                                except Exception:
                                    pass
                                if inputobj != None:
                                    for p in inputobj.mentions:
                                        xtra = p
                                        if xtra not in BLUE_TEAM:
                                            await send_emb_message_to_channel(
                                                0xFF0000,
                                                STARTER[0].mention
                                                + " that player is not on the team you will need to pick someone else",
                                                context,
                                            )
                                        else:
                                            # remove this player
                                            BLUE_TEAM.remove(xtra)
                                            didRemove = True
                                else:  # timeout
                                    await send_emb_message_to_channel(
                                        0xFF0000,
                                        STARTER[0].mention
                                        + " pick the extra player to take off using "
                                        + cmdprefix
                                        + "takeoff @playername in your reply. Current players are:\n\n"
                                        + "\n".join([p.mention for p in BLUE_TEAM]),
                                        context,
                                    )
                else:  # timeout means the admin never replied correctly -> check()
                    await send_emb_message_to_channel_blue(
                        adminRoleMention
                        + " please "
                        + cmdprefix
                        + "transfer if the game starter is missing",
                        context,
                    )
            # blueTeam is full
            # everyone else goes into the redTeam
            for p in PLAYERS:
                if p not in BLUE_TEAM:
                    RED_TEAM.append(p)
            if len(RED_TEAM) < sizeOfTeams:
                # this should never happen, but just in case
                await send_emb_message_to_channel(
                    0xFF0000,
                    "The teams are not even "
                    + STARTER[0].mention
                    + " we need to do this again",
                    context,
                )
                return False
            else:
                # Success, so we need to setup captains to break out of outer loop
                caps.append(BLUE_TEAM[0])
                caps.append(RED_TEAM[0])
                return False
        elif inputobj.content.startswith(cmdprefix + "randcapts"):
            plyrStr = "\n".join([p.mention for p in PLAYERS])
            # first check to see if the admin provided a pool to select from
            try:
                p0 = inputobj.mentions[0]   # throws IndexError (below) if admin did not mention someone
                captainPool = []
                for pZ in inputobj.mentions:
                    if pZ not in PLAYERS:
                            await send_emb_message_to_channel(
                                0xFF0000,
                                STARTER[0].mention
                                + " player must be added to the pickup. Available players are:\n\n"
                                + plyrStr,
                                context,
                            )
                            # player provided is not in pickup - reset
                            return False
                    else:  # add to pool of captains
                        captainPool.append(pZ)
                if len(captainPool) < 2:
                    await send_emb_message_to_channel(
                        0xFF0000,
                        STARTER[0].mention
                        + " you must provide at least two (2) players to pick from. Available players are:\n\n"
                        + plyrStr,
                        context,
                    )
                    return False
                # everything looks good, we can select random captains from the provided list
                shuffle(captainPool)
                caps.append(captainPool[0])
                caps.append(captainPool[1])
                await send_emb_message_to_channel(
                    0x00FF00,
                    "Captains have been randomly selected from the list you provided:\n\n"
                    + "\n".join([p.mention for p in caps]),
                    context,
                )
                return False
            except (IndexError): # otherwise reap from the entire player pool if admin did not mention any players
                if len(PLAYERS) >= 2:
                    caps.append(PLAYERS[0])
                    caps.append(PLAYERS[1])
                    await send_emb_message_to_channel(
                        0x00FF00,
                        "Captains have been randomly selected from the entire player pool:\n\n"
                        + "\n".join([p.mention for p in caps]),
                        context,
                    )
                else:
                    # not enough players
                    caps.append(STARTER[0])
                    caps.append(STARTER[0])
                return False
        elif inputobj.content.startswith(cmdprefix + "shuffle"):
            if len(PLAYERS) >= 2:
                caps.append(PLAYERS[0])
                caps.append(PLAYERS[1])
            else:
                # not enough players
                caps.append(STARTER[0])
                caps.append(STARTER[0])
            return True
        else:
            return False  # not a valid option
    else:  # inputobj == None
        return False  # timeout


async def pick_map(context):
    global CHOSEN_MAP, durationOfMapVote, LAST_MAP, MAP_PICKS, PLAYERS, poolRole, poolRoleID, sizeOfGame, sizeOfMapPool, VOTE_FOR_MAPS
    # vote for maps or random
    if VOTE_FOR_MAPS:
        votelist = {}
        keys = []
        for k, v in MAP_PICKS.items():
            keys.append(v)
        votetotals = []
        [votetotals.append(0) for x in range(sizeOfMapPool)]
        positions = []
        countdown = time.time()
        elapsedtime = time.time() - countdown
        td = timedelta(seconds=elapsedtime)
        counter = 0
        position = 0
        topvote = -1
        duplicateFnd = False
        await send_emb_message_to_channel(
            0x00FF00,
            "Map voting has started\n\n"
            + poolRole.mention
            + " you have "
            + str(durationOfMapVote)
            + " seconds to vote for a map\n\nreply with a number between 1 and "
            + str(sizeOfMapPool)
            + " to cast your vote",
            context,
        )
        await count_votes_message_channel(td, keys, context, votelist, votetotals)
        while td.total_seconds() < durationOfMapVote and len(PLAYERS) == sizeOfGame:

            async def gatherVotes(msg):
                # check function for advance filtering
                def check(msg):
                    # only accept votes from members in the pool
                    # update the vote if they change it
                    if poolRoleID in [r.id for r in msg.author.roles]:
                        for x in range(1, sizeOfMapPool + 1):
                            if msg.content == str(x):
                                votelist.update({msg.author.name: x})
                        return True

                # listen for votes, wait no more than 5 seconds between messages
                # this forces the counter to increment more often (read: more messages to the channel)
                await Bot.wait_for("message", timeout=5, check=check)

            try:
                await gatherVotes(context.message)
            except:
                pass  # to keep the vote going, we want to ignore any exceptions gatherVotes() may have thrown
            elapsedtime = time.time() - countdown
            td = timedelta(seconds=elapsedtime)
            # message everyone the maps votes on every even iteration
            if (counter % 2) == 1 and (td.total_seconds() < durationOfMapVote):
                await count_votes_message_channel(
                    td, keys, context, votelist, votetotals
                )
            counter += 1

        # vote time has expired
        await send_emb_message_to_channel(0xFF0000, "Map voting has finished", context)

        # if users have voted
        if len(votetotals) > 0:
            # tally up the votes
            for k, v in votelist.items():
                votetotals[v - 1] += 1

            # find the max number and it's position
            for pos, vote in enumerate(votetotals):
                if topvote < vote:
                    topvote = vote
                    position = pos

            # now that we have the max and it's position
            # loop one final time to gather positions of duplicates
            for pos, vote in enumerate(votetotals):
                if topvote != vote:
                    continue  # keep looping if they are different
                # topvote == vote therefor we have a tie
                if not duplicateFnd:
                    duplicateFnd = True
                positions.append(pos)
        else:
            duplicateFnd = True
            positions = list(range(1, sizeOfMapPool))

        # randomly pick from list if we have a tie
        if duplicateFnd:
            position = choice(positions)
        CHOSEN_MAP = list(MAP_PICKS.values())[position]
    else:  # random map mode
        selector, CHOSEN_MAP = choice(list(MAP_PICKS.items()))
    # tell the users what map won
    emb = discord.Embed(title="The map has been selected", colour=0x00FF00)
    emb.set_author(name=Bot.user.name, icon_url=Bot.user.avatar_url)
    emb.add_field(name="Map", value=str(CHOSEN_MAP))  # Display the map information
    await context.channel.send(embed=emb)

    LAST_MAP = CHOSEN_MAP  # set for _last()


async def pickup_is_full(context):
    global cmdprefix, PLAYERS, sizeOfGame
    if len(PLAYERS) < sizeOfGame:
        # not full
        await send_emb_message_to_channel(
            0xFF0000, "ABORTING: The pickup is no longer full", context
        )
        await Bot.change_presence(
            activity=discord.Game(
                name="Pickup ("
                + str(len(PLAYERS))
                + "/"
                + str(sizeOfGame)
                + ") "
                + cmdprefix
                + "add"
            )
        )
        return False
    return True


# return the status of PICKUP_RUNNING
async def pickup_is_running(context):
    global PICKUP_RUNNING
    if PICKUP_RUNNING:
        return True
    else:
        await send_emb_message_to_channel(
            0xFF0000,
            context.author.mention
            + " you cannot use this command, there is no pickup running right now. Use "
            + adminRoleMention
            + " to request an admin start one for you",
            context,
        )
        return False


async def post_to_website(playerPoolStr):
    global CHOSEN_MAP, RANDOM_TEAMS, sizeOfGame, STARTER
    if RANDOM_TEAMS:
        mode = "pool"
    else:
        mode = "team"
    payload = {
        "1": STARTER[0].name,
        "2": mode,
        "3": CHOSEN_MAP,
        "4": sizeOfGame,
        "5": playerPoolStr,
        "k": websiteKey,
    }
    resp = requests.post(websiteURL, params=payload)
    if resp.status_code == requests.codes.ok:
        return
    else:
        print("LOG MESSAGE: " + resp.raise_for_status())
        return


# Select the RED_TEAM
async def red_team_picks(caps, context, playerPool):
    global BLUE_TEAM, RED_TEAM, PLAYERS, server
    playerPicked = False
    await send_emb_message_to_channel(
        0x00FF00,
        caps[1].mention
        + " type @player to pick. Available players are:\n\n"
        + "\n".join([p.mention for p in playerPool]),
        context,
    )

    while not playerPicked:
        # check for a pick and catch it if they don't mention an available player
        try:

            def check(msg):
                return msg.author == server.get_member(caps[1].id)

            inputobj = None
            try:
                inputobj = await Bot.wait_for("message", check=check)
            except Exception:
                pass
            picked = inputobj.mentions[0]

            # If the player is in players and they are not already picked, add to the team
            if picked in PLAYERS:
                if picked not in RED_TEAM and picked not in BLUE_TEAM:
                    RED_TEAM.append(picked)
                    try:
                        playerPool.remove(picked)
                    except ValueError:
                        pass  # 'picked' is not in playerPool, so just move on
                    playerPicked = True
                    await send_emb_message_to_channel_red(
                        picked.mention + " has been added to the team", context
                    )
                else:
                    await send_emb_message_to_channel(
                        0xFF0000, picked.mention + " is already on a team", context
                    )
            else:
                await send_emb_message_to_channel(
                    0xFF0000, picked.mention + " is not in this pickup", context
                )
        except (IndexError):
            pass


# remove the poolRoleID from all the players from the last pickup
async def remove_everyone_from_pool_role(context):
    global BLUE_TEAM, poolRole, RED_TEAM
    # remove from all users in both teams
    for p in BLUE_TEAM:
        await p.remove_roles(poolRole)
    for p in RED_TEAM:
        await p.remove_roles(poolRole)
    # reset presence to nothing
    await Bot.change_presence(activity=discord.Game(name=""))


#  after a restart remove the poolRoleID from all the players still have it
async def remove_everyone_from_pool_role_post_restart():
    global server
    for member in server.members:
        for role in member.roles:
            if role == poolRole:
                await member.remove_roles(poolRole)
                break


# update MongoDB with last game information
async def save_last_game_info():
    global BLUE_TEAM, database, LAST_BLUE_TEAM, LAST_TIME, LAST_MAP, LAST_RED_TEAM, RED_TEAM
    LAST_BLUE_TEAM, LAST_RED_TEAM = [], []  # clear
    [LAST_BLUE_TEAM.append(p.name) for p in BLUE_TEAM]
    [LAST_RED_TEAM.append(p.name) for p in RED_TEAM]
    LAST_TIME = time.time()

    # modify the MongoDB document's most recent pickup
    database.pickups.update_one({"last": True}, {"$set": {"last": False}})

    # add new pickup information
    database.pickups.insert_one(
        {
            "blueteam": LAST_BLUE_TEAM,
            "last": True,
            "map": LAST_MAP,
            "redteam": LAST_RED_TEAM,
            "time": LAST_TIME,
        }
    )


# Send a rich embedded messages instead of a plain ones
# to an entire channel
async def send_emb_message_to_channel(colour, embstr, context):
    emb = discord.Embed(description=embstr, colour=colour)
    emb.set_author(name=Bot.user.name, icon_url=Bot.user.avatar_url)
    await context.channel.send(embed=emb)


# Send a rich embedded messages instead of a plain ones
# to an entire channel - Blue Team Logo
async def send_emb_message_to_channel_blue(embstr, context):
    emb = discord.Embed(description=embstr, colour=0x0000FF)
    emb.set_author(
        name="Blue Team",
        icon_url="http://www.lexicondesigns.com/images/other/ff_logo_blue.png",
    )
    await context.channel.send(embed=emb)


# Send a rich embedded messages instead of a plain ones
# to an entire channel - Red Team Logo
async def send_emb_message_to_channel_red(embstr, context):
    emb = discord.Embed(description=embstr, colour=0xFF0000)
    emb.set_author(
        name="Red Team",
        icon_url="http://www.lexicondesigns.com/images/other/ff_logo_red.png",
    )
    await context.channel.send(embed=emb)


# Send a rich embedded messages instead of a plain ones
# to an individual user
async def send_emb_message_to_user(colour, embstr, context):
    emb = discord.Embed(description=embstr, colour=colour)
    emb.set_author(name=Bot.user.name, icon_url=Bot.user.avatar_url)
    await context.author.send(embed=emb)


# send the server information to all of the players in a direct message
# send pickup game information to the channel
async def send_information(context):
    global BLUE_TEAM, CHOSEN_MAP, RED_TEAM, serverID, serverPW
    # set bot presence
    await Bot.change_presence(activity=discord.Game(name="GLHF"))

    # send each user the server and password information
    redTeamMention = []
    blueTeamMention = []
    emb = discord.Embed(
        title="steam://connect/" + serverID + "/" + serverPW, colour=0x00FF00
    )
    emb.set_author(name=Bot.user.name, icon_url=Bot.user.avatar_url)
    # try to message players server info
    # not all players allow messages
    # so pass that exception to get to everyone
    for p in RED_TEAM:
        try:
            await p.send(embed=emb)
        except Exception:
            pass
        redTeamMention.append(
            p.mention
        )  # so we can mention all the members of the red team
    for p in BLUE_TEAM:
        try:
            await p.send(embed=emb)
        except Exception:
            pass
        blueTeamMention.append(
            p.mention
        )  # so we can mention all the members of the blue team

    # Display the game information
    emb = discord.Embed(
        title="The pickup is starting!!\nMap: " + CHOSEN_MAP, colour=0x00FF00
    )
    emb.set_author(name=Bot.user.name, icon_url=Bot.user.avatar_url)
    await context.channel.send(embed=emb)
    await send_emb_message_to_channel_blue(
        "\n".join(map(str, blueTeamMention)), context
    )  # Blue Team information
    await send_emb_message_to_channel_red(
        "\n".join(map(str, redTeamMention)), context
    )  # Red Team information


# create the MongoDB client and connect to the database
async def set_database():
    global database, dbclient
    dbclient = pymongo.MongoClient(dbtoken)
    database = dbclient.FortressForever


# Cycle through a user's roles to determine if they have admin access
# @returns True if they have access
async def user_has_access(author):
    if adminRoleID in [r.id for r in author.roles]:
        return True
    return False


# Cycle through a user's roles to determine if they have new player role
# @returns True if they have the role
async def user_is_new_player(author):
    if newPlayerRoleID in [r.id for r in author.roles]:
        return True
    return False


async def verify_chosen_map_is_good(context):
    global CHOSEN_MAP, cmdprefix, durationOfCheckin, MAP_PICKS, STARTER
    didChoose = False
    await send_emb_message_to_channel(
        0xFFA500,
        STARTER[0].mention
        + " the map is currently set to: "
        + CHOSEN_MAP
        + "\nReply with "
        + cmdprefix
        + "accept - to **accept** the map or "
        + cmdprefix
        + "repick - to discard the map and all nominations and **repick**",
        context,
    )
    while not didChoose:
        # check for advanced filtering
        def check(msg):
            if msg.author == STARTER[0]:
                if msg.content.startswith(
                    cmdprefix + "accept"
                ) or msg.content.startswith(cmdprefix + "repick"):
                    return True
            return False

        inputobj = None
        try:
            inputobj = await Bot.wait_for(
                "message", timeout=durationOfCheckin, check=check
            )
        except Exception:
            pass
        # returns 'None' if asyncio.TimeoutError thrown
        if inputobj != None:
            didChoose = True
            # clear out CHOSEN_MAP and MAP_PICKS if admin wishes to repick
            if inputobj.content.startswith(cmdprefix + "repick"):
                CHOSEN_MAP = []
                MAP_PICKS = {}
        else:
            didChoose = False
            await send_emb_message_to_channel(
                0xFF0000,
                STARTER[0].mention
                + " please make a selection:\n\n"
                + cmdprefix
                + "accept to **accept** the map\n\n"
                + cmdprefix
                + "repick to discard the map and all nominations and **repick**\n\n"
                + CHOSEN_MAP,
                context,
            )


#
# Bot.commands - cmdprefix + help for in-game help
#


# Add
@Bot.command(
    name="add",
    description="Add yourself to the list of players for the current pickup",
    brief="Add to the pickup",
    aliases=["add_me", "addme", "join"],
)
async def _add(context):
    global CHOSEN_MAP, MAP_PICKS, PICKUP_RUNNING, PLAYERS, poolRole, sizeOfGame, STARTER, VOTE_FOR_MAPS
    if await command_is_in_wrong_channel(context):
        return  # To avoid cluttering and confusion, the Bot only listens to one channel
    if not await pickup_is_running(context):
        return  # there must be an active pickup
    # one can only add if:
    # 	they are not already added
    # 	we are not already selecting teams
    if context.author in PLAYERS:
        await send_emb_message_to_channel(
            0xFF0000,
            context.author.mention + " you have already added to this pickup",
            context,
        )
        return
    elif len(PLAYERS) == sizeOfGame:
        await send_emb_message_to_channel(
            0xFF0000,
            context.author.mention
            + " sorry, the game is currently full\nYou will have to wait until the next one starts",
            context,
        )
        return
    else:  # all clear to add them
        # add to pool for easier notification
        try:
            await context.author.add_roles(poolRole)
        except (discord.Forbidden, discord.HTTPException):
            pass
        PLAYERS.append(context.author)
        await send_emb_message_to_channel(
            0x00FF00,
            context.author.mention
            + " you have been added to the pickup.\nThere are currently "
            + str(len(PLAYERS))
            + "/"
            + str(sizeOfGame)
            + " Players in the pickup",
            context,
        )
        await Bot.change_presence(
            activity=discord.Game(
                name="Pickup ("
                + str(len(PLAYERS))
                + "/"
                + str(sizeOfGame)
                + ") "
                + cmdprefix
                + "add"
            )
        )

    # each time someone adds, we need to check to see if the pickup is full
    if len(PLAYERS) == sizeOfGame:
        # start the pickup
        reset = await go_go_gadget_pickup(context)
        if reset:
            # Reset so we can play another one
            CHOSEN_MAP = []
            MAP_PICKS = {}
            PLAYERS = []
            STARTER = []
            PICKUP_RUNNING = False
            VOTE_FOR_MAPS = True


# Add Alias
@Bot.command(
    name="add_alias",
    description="Adds a new alias to an existing map (row) to the maps collection (table) in the MongoDB",
    brief="Add a new map alias",
    aliases=["update_map", "updatemap"],
)
async def _addalias(context):
    global database, server
    if await command_is_in_wrong_channel(context):
        return  # To avoid cluttering and confusion, the Bot only listens to one channel
    # have to manually get these for the Admin Only PM commands
    member = server.get_member(context.author.id)
    # admin command
    if await user_has_access(member):
        message = context.message.content.split()
        if len(message) > 2:
            mpname = message[1]
            # get the new alaises
            aliases = []
            for alias in message[2:]:
                aliases.append(alias)
            # first need to get the existing map and all of it's fields
            updated = database.maps.find_one_and_update(
                filter={},
                query={
                    "$or": [
                        {"name": mpname},
                        {"name": "ff_" + mpname},
                        {"aliases": mpname},
                    ]
                },
                update={"$addToSet": {"aliases": {"$each": aliases}}},
                return_document=ReturnDocument.AFTER,
            )
            if updated:
                await send_emb_message_to_user(
                    0x00FF00,
                    "Map has been updated in the database\n\n"
                    + str(updated["name"])
                    + "\n\nAliases: "
                    + str(updated["aliases"]),
                    context,
                )
            else:
                await send_emb_message_to_user(
                    0xFF0000,
                    "That map does not exist in the database. Did you mean to "
                    + cmdprefix
                    + "addmap?",
                    context,
                )
        else:
            await send_emb_message_to_user(
                0xFF0000,
                context.author.mention
                + "\n\nThat is not how you use this command, use:\n\n"
                + cmdprefix
                + "addalias ("
                + cmdprefix
                + "updatemap) mapname_or_aliais **newalias1** **newalias2** ... **newalias#**\n\nPlease try again",
                context,
            )
    else:
        await send_emb_message_to_channel(
            0xFF0000,
            context.author.mention + " you do not have access to this command",
            context,
        )


# Add Map
@Bot.command(
    name="addmap",
    description="Adds a new map (row) to the maps collection (table) in the MongoDB",
    brief="Add a new map",
    aliases=["add_map", "new_map", "newmap"],
)
async def _addmap(context):
    global database, server
    if await command_is_in_wrong_channel(context):
        return  # To avoid cluttering and confusion, the Bot only listens to one channel
    # have to manually get these for the Admin Only PM commands
    member = server.get_member(context.author.id)
    # admin command
    if await user_has_access(member):
        message = context.message.content.split()
        if len(message) > 1:
            # add the new map the MongoDB
            name = message[1]
            aliases = []
            for alias in message[2:]:
                aliases.append(alias)
            cursor = database.maps.find({"name": name})
            if cursor.count() == 0:
                # Mongo uses documents (key:value pairs) to represent rows of data
                database.maps.insert([{"name": name, "aliases": aliases}])

                # verify we have done this correctly
                last = database.maps.find_one({"name": name})

                await send_emb_message_to_user(
                    0x00FF00,
                    "New map has been added to the database\n\n" + str(last),
                    context,
                )
            else:
                await send_emb_message_to_user(
                    0xFF0000,
                    "That map already exists in the database. Did you mean to "
                    + cmdprefix
                    + "updatemap?",
                    context,
                )
        else:
            await send_emb_message_to_user(
                0xFF0000,
                context.author.mention
                + "\n\nThat is not how you use this command, use:\n\n"
                + cmdprefix
                + "addmap <name> <alias1> <alias2> ... <alias##>\n\nPlease try again",
                context,
            )
    else:
        await send_emb_message_to_channel(
            0xFF0000,
            context.author.mention + " you do not have access to this command",
            context,
        )


# Add Server
@Bot.command(
    name="addserver",
    description="Adds a new server (row) to the servers collection (table) in the MongoDB",
    brief="Add a new server",
    aliases=["add_server", "new_server", "newserver"],
)
async def _addserver(context):
    global database, server
    if await command_is_in_wrong_channel(context):
        return  # To avoid cluttering and confusion, the Bot only listens to one channel
    # have to manually get these for the Admin Only PM commands
    member = server.get_member(context.author.id)
    # admin command
    if await user_has_access(member):
        message = context.message.content.split()
        if len(message) > 4:
            # add the new server the MongoDB
            name = message[1]
            passwd = message[2]
            rcon = message[3]
            if re.match(serverIDRegEx, message[4]):
                serverid = message[4]

                # Mongo uses documents (key:value pairs) to represent rows of data
                database.servers.insert(
                    [
                        {
                            "names": [name],
                            "passwd": passwd,
                            "rcon": rcon,
                            "serverid": serverid,
                        }
                    ]
                )

                # verify we have done this correctly
                last = database.servers.find_one({"names": name})

                await send_emb_message_to_user(
                    0x00FF00,
                    "New server has been added to the database\n\n" + str(last),
                    context,
                )
            else:
                await send_emb_message_to_user(
                    0xFF0000,
                    context.author.mention
                    + "\n\nThat is not a valid server id, use:\n\n"
                    + cmdprefix
                    + "addserver <name> <password> <rcon_password> <###.###.###.###:27015>\n\nPlease try again",
                    context,
                )
        else:
            await send_emb_message_to_user(
                0xFF0000,
                context.author.mention
                + "\n\nThat is not how you use this command, use:\n\n"
                + cmdprefix
                + "addserver <name> <password> <rcon_password> <###.###.###.###:27015>\n\nPlease try again",
                context,
            )
    else:
        await send_emb_message_to_channel(
            0xFF0000,
            context.author.mention + " you do not have access to this command",
            context,
        )


# Admin
@Bot.command(
    name="admin",
    description="Displays the admin who is in control of the current pickup",
    brief="Displays the admin of the current pickup",
    aliases=["game_admin", "gameadmin", "game_starter", "gamestarter", "starter"],
)
async def _admin(context):
    global STARTER
    if await command_is_in_wrong_channel(context):
        return  # To avoid cluttering and confusion, the Bot only listens to one channel
    if not await pickup_is_running(context):
        return  # there must be an active pickup
    else:
        await send_emb_message_to_channel(
            0x00FF00, "Game Admin is: " + STARTER[0].mention, context
        )


# Ban
@Bot.command(
    name="ban",
    description="Admin only command that bans a user from the channel for the period specified\n\n"
    + cmdprefix
    + "ban @user length hour(s)|day(s)|week(s)|month(s)|year(s) (pick one) Reason for the ban",
    brief="Ban a player",
    aliases=["ban_player", "banplayer", "timeout"],
)
async def _ban(context):
    global database, accessRole, MAP_PICKS, PLAYERS, poolRole, timeoutRole
    if await command_is_in_wrong_channel(context):
        return  # To avoid cluttering and confusion, the Bot only listens to one channel
    # admin command
    if await user_has_access(context.author):
        message = context.message.content.split()
        exempli_gratia = (
            "e.g.\n"
            + cmdprefix
            + "ban "
            + context.author.mention
            + " 1 hour abandoned pickup\n"
            + cmdprefix
            + "ban "
            + context.author.mention
            + " 3 days repeatedly abandoning pickups\n"
            + cmdprefix
            + "ban "
            + context.author.mention
            + " 5 month just stop adding already!\n\n"
        )
        if len(message) > 4:
            try:
                banned = context.message.mentions[0]
                exempli_gratia = (
                    "e.g.\n"
                    + cmdprefix
                    + "ban "
                    + banned.mention
                    + " 1 hour abandoned pickup\n"
                    + cmdprefix
                    + "ban "
                    + banned.mention
                    + " 3 days repeatedly abandoning pickups\n"
                    + cmdprefix
                    + "ban "
                    + banned.mention
                    + " 5 month just stop adding already!\n\n"
                )
                if re.match("^[1-9]+[0-9]*$", message[2]):
                    length = message[2]
                    origin = time.time()
                    resolution = message[3]

                    # convert to plural form if necessary
                    if resolution == "minute":
                        resolution = "minutes"
                    elif resolution == "hour":
                        resolution = "hours"
                    elif resolution == "day":
                        resolution = "days"
                    elif resolution == "week":
                        resolution = "weeks"
                    elif resolution == "month":
                        resolution = "months"
                    elif resolution == "year" or resolution == "years":
                        # years are converted to months
                        resolution = "months"
                        length *= 12

                    if (
                        resolution != "minutes"
                        and resolution != "hours"
                        and resolution != "days"
                        and resolution != "weeks"
                        and resolution != "months"
                    ):
                        await send_emb_message_to_channel(
                            0xFF0000,
                            str(resolution)
                            + " is not a valid resolution, it must be either: hour(s), day(s), week(s), month(s), or year(s). Please try again\n\n"
                            + cmdprefix
                            + "ban @user length hour(s)|day(s)|week(s)|month(s)|year(s) (pick one) Reason for the ban\n\n"
                            + exempli_gratia,
                            context,
                        )
                        return

                    duration = length + " " + resolution
                    reason = " ".join(message[4:])

                    # remove access to the channel
                    try:
                        await banned.add_roles(timeoutRole)
                        await asyncio.sleep(2)
                        await banned.remove_roles(accessRole)
                    except (discord.Forbidden, discord.HTTPException):
                        pass

                    # remove them if they are added
                    if banned in PLAYERS:
                        PLAYERS.remove(banned)  # remove from players list
                        MAP_PICKS.pop(
                            banned, None
                        )  # remove this players nomination if they had one
                        try:
                            await banned.remove_roles(poolRole)
                        except Exception:
                            pass

                    # delete any existing ban from the MongoDB
                    database.banned.delete_one({"userid": banned.id})

                    # Add the new ban to the MongoDB
                    if message[2] == 1:
                        database.banned.insert(
                            {
                                "userid": banned.id,
                                "length": duration[:-1],
                                "origin": origin,
                                "reason": reason,
                            }
                        )
                    else:
                        database.banned.insert(
                            {
                                "userid": banned.id,
                                "length": duration,
                                "origin": origin,
                                "reason": reason,
                            }
                        )

                    # Schedule a job to !unban after duration
                    system(
                        'echo "python3 /home/ubuntu/PugBot-for-Discord/unban.py '
                        + str(banned.id)
                        + '" | at now + '
                        + duration
                    )

                    print(
                        "LOG MESSAGE: "
                        + context.author.name
                        + " banned Player: "
                        + str(banned)
                        + " - At time "
                        + time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
                        + " - for a period of "
                        + str(message[2])
                        + " "
                        + str(message[3])
                        + "\nReason given: "
                        + reason
                    )
                    await send_emb_message_to_channel(
                        0x00FF00,
                        banned.mention
                        + " has been banned by "
                        + context.author.mention
                        + " (Admin)\n\nNOTE: This action has been logged",
                        context,
                    )
                    # notify the user
                    emb = discord.Embed(
                        description="You have been banned by an Admin for a period of "
                        + str(message[2])
                        + " "
                        + resolution
                        + "\nReason: "
                        + reason,
                        colour=0x00FF00,
                    )
                    emb.set_author(name=Bot.user.name, icon_url=Bot.user.avatar_url)
                    await banned.send(embed=emb)
                else:
                    await send_emb_message_to_channel(
                        0xFF0000,
                        '"'
                        + str(message[2])
                        + '" is not a valid length, it must be a number. Please try again\n\n'
                        + cmdprefix
                        + "ban @user length hour(s)|day(s)|week(s)|month(s)|year(s) (pick one) Reason for the ban\n\n"
                        + exempli_gratia,
                        context,
                    )
            except (IndexError):
                await send_emb_message_to_channel(
                    0xFF0000,
                    "You must @mention the user. Please try again\n\n"
                    + cmdprefix
                    + "ban @user length hour(s)|day(s)|week(s)|month(s)|year(s) (pick one) Reason for the ban\n\n"
                    + exempli_gratia,
                    context,
                )
        else:
            await send_emb_message_to_channel(
                0xFF0000,
                context.author.mention
                + "\n\nThat is not how you use this command, use:\n\n"
                + cmdprefix
                + "ban @user length hour(s)|day(s)|week(s)|month(s)|year(s) (pick one) Reason for the ban\n\n"
                + exempli_gratia
                + "Please try again",
                context,
            )
    else:
        await send_emb_message_to_channel(
            0xFF0000,
            context.author.mention + " you do not have access to this command",
            context,
        )


# Banned
@Bot.command(
    name="banned",
    description="List all the bans currently saved in the mongoDB\n\n"
    + cmdprefix
    + "banned",
    brief="List all banned players",
    aliases=["banned_player", "bannedplayer", "banned_players", "bannedplayers"],
)
async def _banned(context):
    global database, server
    await set_database()
    # return all documents in the banned collection
    foundmaps = database.banned.find({})
    # convert to a list so we can index into it
    bannedUsers = list(foundmaps)
    # setup the embed and send the message
    emb = discord.Embed(
        description="The following players are currently banned:", colour=0xFFA500
    )
    emb.set_author(name=Bot.user.name, icon_url=Bot.user.avatar_url)
    for banned in bannedUsers:
        try:
            member = server.get_member(banned["userid"])
            time = datetime.datetime.fromtimestamp(banned["origin"])
            emb.add_field(
                name=str(member.name) + " at " + time.strftime("%H:%M:%S %m-%d-%Y"),
                value=str(banned["length"]) + " - " + str(banned["reason"]),
                inline=False,
            )
        except Exception:
            pass  # skip any errors trying to get a user who has left the server
    await context.channel.send(embed=emb)


# Bitcoin
@Bot.command(
    name="bitcoin",
    description="Get the current price of bitcoin in USD",
    brief="Convert BTC to USD",
    aliases=["btc"],
)
async def _bitcoin(context):
    url = "https://api.coindesk.com/v1/bpi/currentprice/BTC.json"
    response = requests.get(url)
    value = response.json()["bpi"]["USD"]["rate"]
    await context.send("Bitcoin price is currently: $" + value)


# Changelevel
@Bot.command(
    name="changelevel",
    description="Change the map in the server using the RCON command changelevel",
    brief="Change the map in server",
    aliases=[
        "changemap",
        "rcon changemap",
        "rcon_changemap",
        "rcon changelevel",
        "rcon_changelevel",
    ],
)
async def _changelevel(context):
    global rcon, server_address, rconPW
    if await command_is_in_wrong_channel(context):
        return  # To avoid cluttering and confusion, the Bot only listens to one channel
    # admin command
    if await user_has_access(context.author):
        message = context.message.content.split()
        # make sure the user provided a map
        if len(message) > 1:
            # check to see if the provided map is in the database
            atom = await mapname_is_valid(message[1])
            if atom != "INVALID":
                # change the map in the server to the provided map
                try:
                    rcon = valve.rcon.RCON(server_address, rconPW)
                    rcon.connect()
                    rcon.authenticate()
                    resp = rcon.execute("changelevel " + atom)
                    print(
                        "LOG MESSAGE: RCON command <changelevel "
                        + atom
                        + "> response received\n\t"
                        + str(resp)
                        + "\nAt time "
                        + time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
                    )
                except Exception as inst:
                    print(inst)
                    pass
                await send_emb_message_to_channel(
                    0x00FF00,
                    context.author.mention + " the map has been changed to " + atom,
                    context,
                )
            else:
                await send_emb_message_to_channel(
                    0xFF0000,
                    context.author.mention
                    + " that map is not in my "
                    + cmdprefix
                    + "maplist. Please make another selection",
                    context,
                )
                await list_all_the_maps(context.message)
        else:
            await send_emb_message_to_channel(
                0xFF0000,
                context.author.mention
                + " you must provide a mapname. "
                + cmdprefix
                + "changemap mapname",
                context,
            )
    else:
        await send_emb_message_to_channel(
            0xFF0000,
            context.author.mention + " you do not have access to this command",
            context,
        )


# Delete Map
@Bot.command(
    name="delmap",
    description="Removes an existing map (row) from the maps collection (table) in the MongoDB",
    brief="Delete an existing map",
    aliases=["del_map", "delete_map", "deletemap"],
)
async def _delmap(context):
    global database, server
    if await command_is_in_wrong_channel(context):
        return  # To avoid cluttering and confusion, the Bot only listens to one channel
    # have to manually get these for the Admin Only PM commands
    member = server.get_member(context.author.id)
    # admin command
    if await user_has_access(member):
        message = context.message.content.split()
        if len(message) > 1:
            name = message[1]

            # Mongo uses documents (key:value pairs) to represent rows of data
            removed = database.maps.delete_one({"name": name})
            print(
                "LOG MESSAGE: "
                + context.author.name
                + " deleted MAP: "
                + name
                + " - At time "
                + time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
            )
            await send_emb_message_to_user(
                0x00FF00,
                "Map has been removed from the database\n\n"
                + str(removed)
                + "\n\nNOTE: This action has been logged",
                context,
            )
        else:
            await send_emb_message_to_user(
                0xFF0000,
                context.author.mention
                + "\n\nThat is not how you use this command, use:\n\n"
                + cmdprefix
                + "delmap <name>\n\nYour entries must match exactly. Please try again",
                context,
            )
    else:
        await send_emb_message_to_channel(
            0xFF0000,
            context.author.mention + " you do not have access to this command",
            context,
        )


# Delete Server - Removes an existing server (read: row) from the servers collection (read: table) in the MongoDB
@Bot.command(
    name="delserver",
    description="Removes an existing map (row) from the maps collection (table) in the MongoDB",
    brief="Delete an existing server",
    aliases=["del_server", "delete_server", "deleteserver"],
)
async def _delserver(context):
    global database, server
    if await command_is_in_wrong_channel(context):
        return  # To avoid cluttering and confusion, the Bot only listens to one channel
    # have to manually get these for the Admin Only PM commands
    member = server.get_member(context.author.id)
    # admin command
    if await user_has_access(member):
        message = context.message.content.split()
        if len(message) > 4:
            # add the new server the MongoDB
            name = message[1]
            passwd = message[2]
            rcon = message[3]
            if re.match(serverIDRegEx, message[4]):
                serverid = message[4]

                query = {
                    "names": [name],
                    "passwd": passwd,
                    "rcon": rcon,
                    "serverid": serverid,
                }
                # Mongo uses documents (key:value pairs) to represent rows of data
                removed = database.servers.delete_one(query)
                print(
                    "LOG MESSAGE: "
                    + context.author.name
                    + " deleted server: "
                    + str(query)
                    + " - At time "
                    + time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
                )
                await send_emb_message_to_user(
                    0x00FF00,
                    "Server has been removed from the database\n\n"
                    + str(removed)
                    + "\n\nNOTE: This action has been logged",
                    context,
                )
            else:
                await send_emb_message_to_user(
                    0xFF0000,
                    context.author.mention
                    + "\n\nThat is not a valid server id, use:\n\n"
                    + cmdprefix
                    + "addserver <name> <password> <rcon_password> <###.###.###.###:27015>\n\nPlease try again",
                    context,
                )
        else:
            await send_emb_message_to_user(
                0xFF0000,
                context.author.mention
                + "\n\nThat is not how you use this command, you must do:\n\n"
                + cmdprefix
                + "delserver name password rcon_password ###.###.###.###:27015\n\nYour entries must match exactly. Please try again",
                context,
            )
    else:
        await send_emb_message_to_channel(
            0xFF0000,
            context.author.mention + " you do not have access to this command",
            context,
        )


# Demos
@Bot.command(
    name="demos",
    description="Provides the message author with a link to the currently stored demos via direct message",
    brief="Get a link to the demos",
    aliases=["demo", "recordings", "recording"],
)
async def _demos(context):
    await send_emb_message_to_user(
        0xFFA500,
        "SourceTV demos can be found here: http://www.ffpickup.com/?p=demos",
        context,
    )


# End
@Bot.command(
    name="end",
    description="Admin only command that ends the current pickup",
    brief="End the current pickup",
    aliases=["edn", "kill", "ned", "stop"],
)
async def _end(context):
    global CHOSEN_MAP, MAP_PICKS, PICKUP_RUNNING, PLAYERS, poolRole, STARTER
    if await command_is_in_wrong_channel(context):
        return  # To avoid cluttering and confusion, the Bot only listens to one channel
    if not await pickup_is_running(context):
        return  # there must be an active pickup
    # admin command
    if await user_has_access(context.author):
        # only end if admin is game_starter or game_starter does not !veto in time
        if STARTER[0] == context.author or not await check_for_veto(
            cmdprefix + "end", context
        ):
            CHOSEN_MAP = []
            MAP_PICKS.clear()
            for p in PLAYERS:
                try:
                    await p.remove_roles(poolRole)
                except Exception:
                    pass
            del PLAYERS[:]
            del STARTER[:]
            PICKUP_RUNNING = False
            await send_emb_message_to_channel(
                0x00FF00, "The pickup has been ended by an admin", context
            )
            await Bot.change_presence(activity=discord.Game(name=" "))
        else:
            await send_emb_message_to_channel(
                0xFF0000, STARTER[0].mention + " has vetoed the command", context
            )
    else:
        await send_emb_message_to_channel(
            0xFF0000,
            context.author.mention + " you do not have access to this command",
            context,
        )


# Force Nominate
@Bot.command(
    name="forcenominate",
    description="Admin only command to force a nomination of the map you specified, for the player you specified",
    brief="Force Nominate the specified map for a player",
    aliases=["forceelect", "forcenom", "forcenomination", "force_elect", "force_nominate", "force_nom", "force_nomination"],
)
async def _forcenominate(context):
    global CHOSEN_MAP, MAP_PICKS, PLAYERS, sizeOfMapPool, STARTER
    if await command_is_in_wrong_channel(context):
        return  # To avoid cluttering and confusion, the Bot only listens to one channel
    # admin command
    if await user_has_access(context.author):
        if not await pickup_is_running(context):
            return  # there must be an active pickup

        # only allow if pickup has not already begun
        if len(CHOSEN_MAP) > 0:
            await send_emb_message_to_channel(
                0xFF0000,
                context.author.mention
                + " you cannot force nominate maps once the map has already been chosen\nCurrent Map: "
                + CHOSEN_MAP,
                context,
            )
        else:
            # check for a pick and catch it if they didn't mention an available player
            try:
                nominatee = context.message.mentions[0]
                # must also be added to the current pickup
                if nominatee in PLAYERS:
                    message = context.message.content.split()
                    # make sure the user provided a map
                    if len(message) > 2:
                        # check to see if the provided map is valid`
                        atom = await mapname_is_valid(message[2])
                        if atom != "INVALID":
                            # only allow a certain number of maps
                            if len(MAP_PICKS) < sizeOfMapPool or nominatee in MAP_PICKS:
                                # users may only nominate one map
                                MAP_PICKS.update({nominatee: atom})
                                await send_emb_message_to_channel(
                                    0x00FF00,
                                    context.author.mention
                                    + " has nominated "
                                    + atom
                                    + " for "
                                    + nominatee.mention,
                                    context,
                                )
                            else:
                                # need to build the list of maps
                                mapStr = ""
                                for k in MAP_PICKS:
                                    mapStr = (
                                            mapStr + str(MAP_PICKS[k]) + " (" + k.mention + ")\n"
                                    )
                                emb = discord.Embed(
                                    description=context.author.mention
                                                + " there is already more than "
                                                + str(sizeOfMapPool)
                                                + " maps nominated, try force nominating one of these users instead",
                                    colour=0xFF0000,
                                )
                                emb.set_author(name=Bot.user.name, icon_url=Bot.user.avatar_url)
                                emb.add_field(name="Current Maps", value=mapStr, inline=False)
                                await context.channel.send(embed=emb)
                        else:
                            await send_emb_message_to_channel(
                                0xFF0000,
                                context.author.mention
                                + " that map is not in my "
                                + cmdprefix
                                + "maplist. Please make another selection",
                                context,
                            )
                            await list_all_the_maps(context.message)
                    else:
                        await send_emb_message_to_channel(
                            0xFF0000,
                            context.author.mention
                            + " that is not how you use this command, you need to do:\n\n"
                            + cmdprefix
                            + " @nameOfAddedPlayer map\n\ne.g. "
                            + cmdprefix
                            + "forcenominate "
                            + context.author.mention
                            + "ff_2fort",
                            context,
                        )
                else:
                    await send_emb_message_to_channel(
                        0xFF0000,
                        context.author.mention
                        + " that player is not added to the pickup",
                        context,
                    )
            except (IndexError):
                await send_emb_message_to_channel(
                    0xFF0000,
                    context.author.mention
                    + " that is not how you use this command, you need to do:\n\n"
                    + cmdprefix
                    + " @nameOfAddedPlayer map\n\ne.g. "
                    + cmdprefix
                    + "forcenominate "
                    + context.author.mention
                    + "ff_2fort",
                    context,
                )
                return  # break out if they did not specify a user
    else:
        await send_emb_message_to_channel(
            0xFF0000,
            context.author.mention + " you do not have access to this command",
            context,
        )


# Hawking
@Bot.command(
    name="hawking",
    description="Displays a random quote from The Great Dr. Hawking",
    brief="Quote from Dr. Stephen Hawking",
    aliases=["hawking_quote", "hawkingquote", "quote"],
)
async def _hawking(context):
    quote, source = choice(list(quotes.items()))
    emb = discord.Embed(description=quote, colour=0x5E7750)
    emb.set_author(
        name="Dr. Stephen William Hawking, 1942-2018", icon_url=Bot.user.avatar_url
    )
    emb.add_field(name="Source:", value=source, inline=False)
    await context.channel.send(embed=emb)


# Journals
@Bot.command(
    name="journals",
    description="Displays a link to 55 papers in Physical Review D and Physical Review Letters, gathered together and made public by the American Physical Society",
    brief="Link to Stephen Hawking journals",
    aliases=[
        "aps",
        "american_physical_society",
        "americanphysicalsociety",
        "hawking_journal",
        "hawkingjournal",
        "hawking_journals",
        "hawkingjournals",
        "journal",
    ],
)
async def _journals(context):
    emb = discord.Embed(
        description="""To mark the passing of Stephen Hawking, the American Physical Society have gathered together and made free to read his 55 papers in the peer-reviewed, scientific journals Physical Review D and Physical Review Letters.""",
        colour=0x5E7750,
    )
    emb.set_author(
        name="Dr. Stephen William Hawking, 1942-2018", icon_url=Bot.user.avatar_url
    )
    emb.add_field(
        name="Link:",
        value="https://journals.aps.org/collections/stephen-hawking",
        inline=False,
    )
    await context.channel.send(embed=emb)


# Last
@Bot.command(
    name="last",
    description="Displays information about the last pickup that was played",
    brief="Show the last pickup info",
    aliases=["last_game", "lastgame", "last_pug", "lastpug"],
)
async def _last(context):
    global database, dbclient, LAST_BLUE_TEAM, LAST_TIME, LAST_MAP, LAST_RED_TEAM
    if await command_is_in_wrong_channel(context):
        return  # To avoid cluttering and confusion, the Bot only listens to one channel
    await set_database()
    found = database.pickups.find_one({"last": True})
    LAST_BLUE_TEAM = found.get("blueteam")
    LAST_RED_TEAM = found.get("redteam")
    LAST_MAP = found.get("map")
    LAST_TIME = found.get("time")

    # set up the timedelta
    elapsedtime = time.time() - LAST_TIME
    td = timedelta(seconds=elapsedtime)
    td = td - timedelta(microseconds=td.microseconds)

    # we have to send these as multiple embed messages
    # if we try to send more than 2000 characters discord raises a 400 request error
    emb = discord.Embed(
        title="Last Pickup was " + str(td) + " ago on " + LAST_MAP, colour=0x00FF00
    )
    emb.set_author(name=Bot.user.name, icon_url=Bot.user.avatar_url)
    await context.channel.send(embed=emb)
    await send_emb_message_to_channel_blue("\n".join(map(str, LAST_BLUE_TEAM)), context)
    await send_emb_message_to_channel_red("\n".join(map(str, LAST_RED_TEAM)), context)
    # close the database
    dbclient.close()


# Last Five
@Bot.command(
    name="lastfive",
    description="Displays information about the last 5 pickups that were played",
    brief="Show info about the last 5 pickups",
    aliases=["last_five", "last_5", "last5"],
)
async def _lastfive(context):
    global database, dbclient, LAST_BLUE_TEAM, LAST_TIME, LAST_MAP, LAST_RED_TEAM
    if await command_is_in_wrong_channel(context):
        return  # To avoid cluttering and confusion, the Bot only listens to one channel
    await set_database()
    iCount = 0
    pugs = database.pickups.find({})
    pugs.sort( "_id", pymongo.DESCENDING )
    for pug in pugs:
        if iCount >= 5:
            break
        LAST_BLUE_TEAM = pug.get("blueteam")
        LAST_RED_TEAM = pug.get("redteam")
        LAST_MAP = pug.get("map")
        LAST_TIME = pug.get("time")

        # set up the timedelta
        elapsedtime = time.time() - LAST_TIME
        td = timedelta(seconds=elapsedtime)
        td = td - timedelta(microseconds=td.microseconds)

        # we have to send these as multiple embed messages
        # if we try to send more than 2000 characters discord raises a 400 request error
        emb = discord.Embed(
            title="Pickup was " + str(td) + " ago on " + LAST_MAP, colour=0x00FF00
        )
        emb.set_author(name=Bot.user.name, icon_url=Bot.user.avatar_url)
        await context.channel.send(embed=emb)
        # too much spam with all three messages, for now only send mapname and time
        #await send_emb_message_to_channel_blue("\n".join(map(str, LAST_BLUE_TEAM)), context)
        #await send_emb_message_to_channel_red("\n".join(map(str, LAST_RED_TEAM)), context)
        iCount += 1
    dbclient.close()
    url = flaskServerURL + "/pickup"
    await send_emb_message_to_channel(
        0x00FF00,
        "For more information visit ["
        + url
        + "]("
        + url
        + ")",
        context
    )
    return


# Map
@Bot.command(
    name="map",
    description="Show the chosen map for the current pickup",
    brief="Show the selected map",
    aliases=["what_map_won", "whatmapwon"],
)
async def _map(context):
    global CHOSEN_MAP
    if await command_is_in_wrong_channel(context):
        return  # To avoid cluttering and confusion, the Bot only listens to one channel
    if not await pickup_is_running(context):
        return  # there must be an active pickup
    # only allow if pickup selection has already begun
    if len(CHOSEN_MAP) > 0:
        await send_emb_message_to_channel(
            0x00FF00, "The map for this pickup is " + CHOSEN_MAP, context
        )
    else:
        await send_emb_message_to_channel(
            0xFF0000,
            context.author.mention
            + " there has not been a map pick for this pickup yet",
            context,
        )


# Maps
@Bot.command(
    name="maps",
    description="List all of the maps that have been nominated for the current pickup",
    brief="Show the nominated maps",
    aliases=["nominated", "nominate_maps", "nominatedmaps"],
)
async def _maps(context):
    global MAP_PICKS, sizeOfMapPool
    if await command_is_in_wrong_channel(context):
        return  # To avoid cluttering and confusion, the Bot only listens to one channel
    if not await pickup_is_running(context):
        return  # there must be an active pickup
    # need to build the list of maps
    mapStr = ""
    for k in MAP_PICKS:
        mapStr = mapStr + str(MAP_PICKS[k]) + " (" + k.mention + ")\n"
    await send_emb_message_to_channel(
        0x00FF00,
        "Current Maps ("
        + str(len(MAP_PICKS))
        + "/"
        + str(sizeOfMapPool)
        + ")\n"
        + mapStr,
        context,
    )


# Maplist
@Bot.command(
    name="maplist",
    description="Provides you with a list of all the maps that are available for nomination via direct message",
    brief="Show the list of maps available",
    aliases=["list_maps", "listmaps", "map_list"],
)
async def _maplist(context):
    if await command_is_in_wrong_channel(context):
        return  # To avoid cluttering and confusion, the Bot only listens to one channel
    await list_all_the_maps(context.message)


# Nominate
@Bot.command(
    name="nominate",
    description="Nominate the map you specified, provided it is valid",
    brief="Nominate the specified map",
    aliases=["elect", "iwanttoplay", "nom"],
)
async def _nominate(context):
    global CHOSEN_MAP, MAP_PICKS, PLAYERS, sizeOfMapPool, STARTER
    if await command_is_in_wrong_channel(context):
        return  # To avoid cluttering and confusion, the Bot only listens to one channel
    if not await pickup_is_running(context):
        return  # there must be an active pickup
    if await user_is_new_player(context.author):
        await send_emb_message_to_channel(
            0xFF0000,
            context.author.mention
            + " I'm sorry, users with the "
            + newPlayerRoleStr
            + " role cannot nominate maps. If you feel this role has been assigned by mistake, use "
            + adminRoleMention
            + " to request an admin remove the role",
            context,
        )
        return # do not allow new players to nominate maps
    # only allow if pickup has not already begun
    if len(CHOSEN_MAP) > 0:
        await send_emb_message_to_channel(
            0xFF0000,
            context.author.mention
            + " you cannot nominate maps once the map has already been chosen\nCurrent Map: "
            + CHOSEN_MAP,
            context,
        )
    else:
        # must also be added to the current pickup
        if context.author in PLAYERS:
            message = context.message.content.split()
            # make sure the user provided a map
            if len(message) > 1:
                # check to see if the provided map is valid
                atom = await mapname_is_valid(message[1])
                if atom != "INVALID":
                    # check to see if someone else nominated this map
                    for a, mp in MAP_PICKS.items():
                        if atom == str(mp):
                            await send_emb_message_to_channel(
                                0xFF0000,
                                context.author.mention
                                + " that map has already been nominated. Please make another selection",
                                context,
                            )
                            return  # break out if duplicate nomination

                    if await map_was_recently_played(atom):
                        await send_emb_message_to_channel(
                            0xFF0000,
                            context.author.mention
                            + " that map has been played too recently (within the last "
                            + str(sizeOfRecentMap)
                            + " pickups). Please make another selection",
                            context,
                        )
                        return  # only allow maps that have not been recently played

                    # only allow a certain number of maps
                    if len(MAP_PICKS) < sizeOfMapPool or context.author in MAP_PICKS:
                        # users may only nominate one map
                        MAP_PICKS.update({context.author: atom})
                        await send_emb_message_to_channel(
                            0x00FF00,
                            context.author.mention + " has nominated " + atom,
                            context,
                        )
                    else:
                        # need to build the list of maps
                        mapStr = ""
                        for k in MAP_PICKS:
                            mapStr = (
                                mapStr + str(MAP_PICKS[k]) + " (" + k.mention + ")\n"
                            )
                        emb = discord.Embed(
                            description=context.author.mention
                            + " there is already more than "
                            + str(sizeOfMapPool)
                            + " maps nominated",
                            colour=0xFF0000,
                        )
                        emb.set_author(name=Bot.user.name, icon_url=Bot.user.avatar_url)
                        emb.add_field(name="Current Maps", value=mapStr, inline=False)
                        await context.channel.send(embed=emb)
                else:
                    await send_emb_message_to_channel(
                        0xFF0000,
                        context.author.mention
                        + " that map is not in my "
                        + cmdprefix
                        + "maplist. Please make another selection",
                        context,
                    )
                    await list_all_the_maps(context.message)
            else:
                await send_emb_message_to_channel(
                    0xFF0000,
                    context.author.mention
                    + " that is not how you use this command, use:\n\n"
                    + cmdprefix
                    + "nominate mapname",
                    context,
                )
        else:
            await send_emb_message_to_channel(
                0xFF0000,
                context.author.mention
                + " you cannot use this command, you must be added to the pickup to nominate maps",
                context,
            )


# Perma-Ban
@Bot.command(
    name="permaban",
    description="Admin only command that bans a user from the channel FOREVER\n\n"
    + cmdprefix
    + "permaban @user Reason for the ban",
    brief="Permanently ban a player",
    aliases=["perma_ban", "permaban_player", "permabanplayer"],
)
async def _permaban(context):
    global database, accessRole, MAP_PICKS, PLAYERS, poolRole, timeoutRole
    if await command_is_in_wrong_channel(context):
        return  # To avoid cluttering and confusion, the Bot only listens to one channel
    # admin command
    if await user_has_access(context.author):
        message = context.message.content.split()
        if len(message) > 2:
            try:
                banned = context.message.mentions[0]
                origin = time.time()
                reason = " ".join(message[2:])

                # remove access to the channel
                try:
                    await banned.add_roles(timeoutRole)
                    await asyncio.sleep(2)
                    await banned.remove_roles(accessRole)
                except (discord.Forbidden, discord.HTTPException):
                    pass

                # remove them if they are added
                if banned in PLAYERS:
                    PLAYERS.remove(banned)  # remove from players list
                    MAP_PICKS.pop(
                        banned, None
                    )  # remove this players nomination if they had one
                    try:
                        await banned.remove_roles(poolRole)
                    except Exception:
                        pass

                # delete any existing ban from the MongoDB
                database.banned.delete_many({"userid": banned.id})

                # Add the new ban to the MongoDB
                database.banned.insert(
                    {
                        "userid": banned.id,
                        "length": 9999,
                        "origin": origin,
                        "reason": reason,
                    }
                )

                print(
                    "LOG MESSAGE: "
                    + context.author.name
                    + " PERMA-banned Player: "
                    + str(banned)
                    + " - At time "
                    + time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
                    + "\nReason given: "
                    + reason
                )
                await send_emb_message_to_channel(
                    0x00FF00,
                    banned.mention
                    + " has been permanently banned by "
                    + context.author.mention
                    + " (Admin)\n\nNOTE: This action has been logged",
                    context,
                )
                # notify the user
                emb = discord.Embed(
                    description="You have been permanently banned from this channel by an Admin"
                    + "\nReason: "
                    + reason,
                    colour=0x00FF00,
                )
                emb.set_author(name=Bot.user.name, icon_url=Bot.user.avatar_url)
                await banned.send(embed=emb)
            except IndexError:
                await send_emb_message_to_channel(
                    0xFF0000,
                    "You must @mention the user, please try again\n\n"
                    + cmdprefix
                    + "permaban @user Reason for the ban\n\ne.g.\n!permaban "
                    + context.author.mention
                    + " tired of banning you\n\n",
                    context,
                )
        else:
            await send_emb_message_to_channel(
                0xFF0000,
                context.author.mention
                + "\n\nThat is not how you use this command, use:\n\n"
                + cmdprefix
                + "permaban @user Reason for the ban\n\ne.g.\n!permaban "
                + context.author.mention
                + " tired of banning you\n\nPlease try again",
                context,
            )
    else:
        await send_emb_message_to_channel(
            0xFF0000,
            context.author.mention + " you do not have access to this command",
            context,
        )


# Pickup
@Bot.command(
    name="pickup",
    description="Start a new pickup, if one is not already currently running",
    brief="Start a new pickup",
    aliases=[
        "new_game",
        "newgame",
        "new",
        "new_pickup",
        "pikcup",
        "start",
        "start_game",
    ],
)
async def _pickup(context):
    global PICKUP_RUNNING, PLAYERS, sizeOfGame, sizeOfTeams, START_TIME, STARTER
    if await command_is_in_wrong_channel(context):
        return  # To avoid cluttering and confusion, the Bot only listens to one channel
    # admin command
    if await user_has_access(context.author):
        # only start one if there is not already one running
        if PICKUP_RUNNING:
            await send_emb_message_to_channel(
                0xFF0000,
                "There is already a pickup running. "
                + cmdprefix
                + "teams to see the game details",
                context,
            )
        else:
            PICKUP_RUNNING = True
            STARTER.clear()
            STARTER.append(context.author)
            sizeOfGame = config.sizeOfGame
            sizeOfTeams = config.sizeOfTeams
            await send_emb_message_to_channel(
                0x00FF00,
                "A pickup has been started. " + cmdprefix + "add to join up.",
                context,
            )
            await Bot.change_presence(
                activity=discord.Game(
                    name="Pickup ("
                    + str(len(PLAYERS))
                    + "/"
                    + str(sizeOfGame)
                    + ") "
                    + cmdprefix
                    + "add"
                )
            )
            START_TIME = time.time()
    else:
        await send_emb_message_to_channel(
            0xFF0000,
            context.author.mention + " you do not have access to this command",
            context,
        )


# Players
@Bot.command(
    name="players",
    description="Change the number of players per team (Admin only)",
    brief="Change the number of players in pickup",
    aliases=[
        "players_per_team",
        "size_of_teams",
        "sizeofteams",
        "team_size",
        "teamsize",
    ],
)
async def _players(context):
    global PLAYERS, sizeOfGame, sizeOfTeams, STARTER
    if await command_is_in_wrong_channel(context):
        return  # To avoid cluttering and confusion, the Bot only listens to one channel
    if not await pickup_is_running(context):
        return  # there must be an active pickup
    # admin command
    if await user_has_access(context.author):
        # make sure this admin owns this pickup
        if STARTER[0] == context.author:
            message = context.message.content.split()
            if len(message) >= 1:
                # make sure the msg.author is giving an integer value
                try:
                    sz = int(message[1])
                    if sz == 0:
                        # zero players? Just end it then
                        await send_emb_message_to_channel(
                            0xFF0000,
                            context.author.mention
                            + " you cannot change to zero players, please use "
                            + cmdprefix
                            + "end instead",
                            context,
                        )
                    elif (sz % 2) == 0:
                        # even number
                        if sz < len(PLAYERS):
                            # do not lower sizes if more players have added already
                            await send_emb_message_to_channel(
                                0xFF0000,
                                context.author.mention
                                + " the player pool is too big to change to that value",
                                context,
                            )
                        else:
                            sizeOfTeams = int(sz / 2)
                            sizeOfGame = int(sz)
                            await send_emb_message_to_channel(
                                0x00FF00,
                                context.author.mention
                                + " the size of the game has been changed to "
                                + str(sz),
                                context,
                            )
                            await Bot.change_presence(
                                activity=discord.Game(
                                    name="Pickup ("
                                    + str(len(PLAYERS))
                                    + "/"
                                    + str(sizeOfGame)
                                    + ") "
                                    + cmdprefix
                                    + "add"
                                )
                            )
                    else:  # odd number
                        await send_emb_message_to_channel(
                            0xFF0000,
                            context.author.mention
                            + " the size of the teams must be even",
                            context,
                        )
                except (ValueError):
                    await send_emb_message_to_channel(
                        0xFF0000,
                        context.author.mention
                        + " "
                        + message[1]
                        + " is not a valid number. Use "
                        + cmdprefix
                        + "players #",
                        context,
                    )
            else:
                await send_emb_message_to_channel(
                    0xFF0000,
                    "You must provide a new size "
                    + cmdprefix
                    + "players numberOfPlayers",
                    context,
                )
        else:
            await send_emb_message_to_channel(
                0xFF0000,
                context.author.mention
                + " sorry, this pickup does not belong to you, it belongs to "
                + STARTER[0].mention,
                context,
            )
    else:
        await send_emb_message_to_channel(
            0xFF0000,
            context.author.mention + " you do not have access to this command",
            context,
        )


# Pug
@Bot.command(
    name="pug",
    description="Allow user access to the pickup channel ",
    brief="Give you access to the channel",
    aliases=["letmein"],
)
async def _pug(context):
    global accessRole, newPlayerRole, requestChannelID, timeoutRoleID
    if await command_is_in_wrong_channel(context):
        return  # To avoid cluttering and confusion, the Bot only listens to one channel
    try:
        await context.author.add_roles(accessRole)
        await send_emb_message_to_channel(
            0x00FF00, "Successfully added role {0}".format(accessRole.name), context
        )
        await context.author.add_roles(newPlayerRole)
        await send_emb_message_to_channel(
            0x00FF00, "Successfully added role {0}".format(newPlayerRole.name), context
        )
    except (discord.Forbidden, discord.HTTPException):
        pass


# Pugbot (Magic 8-Ball)
@Bot.command(
    name="pugbot",
    description="Answers a yes or no question",
    brief="Answers from the pugbot",
    aliases=["8ball", "8-ball", "eight_ball", "eightball"],
)
async def _eight_ball(context):
    possible_responses = [
        "It is certain",
        "It is decidedly so",
        "Without a doubt",
        "Yes - definitely",
        "You may rely on it",
        "As I see it, yes",
        "Most likely",
        "Outlook good",
        "Yes",
        "Signs point to yes",
        "Reply hazy, try again",
        "Ask again later",
        "Better not tell you now",
        "Cannot predict now",
        "Concentrate and ask again",
        "Don't count on it",
        "My reply is no",
        "My sources say no",
        "Outlook not so good",
        "Very doubtful",
    ]
    await context.send(choice(possible_responses) + " " + context.author.mention)


# Radicaldad
@Bot.command(name="radicaldad", description="", brief="Not for you")
async def _radicaldad(context):
    global CHOSEN_MAP, MAP_PICKS, PICKUP_RUNNING, PLAYERS, poolRole, sizeOfGame, STARTER, vipPlayerID, VOTE_FOR_MAPS
    # same as add but with the restriction on ID
    if context.author.id == vipPlayerID:
        if not await pickup_is_running(context):
            return  # there must be an active pickup
        if context.author in PLAYERS:
            await send_emb_message_to_channel(
                0xFF0000,
                context.author.mention + " you have already added to this pickup",
                context,
            )
            return
        elif len(PLAYERS) == sizeOfGame:
            await send_emb_message_to_channel(
                0xFF0000,
                context.author.mention
                + " sorry, the game is currently full\nYou will have to wait until the next one starts",
                context,
            )
            return
        else:  # all clear to add them
            # add to pool for easier notification
            try:
                await context.author.add_roles(poolRole)
            except (discord.Forbidden, discord.HTTPException):
                pass
            PLAYERS.append(context.author)
            await send_emb_message_to_channel(
                0x00FF00,
                context.author.mention
                + " you have been added to the pickup.\nThere are currently "
                + str(len(PLAYERS))
                + "/"
                + str(sizeOfGame)
                + " Players in the pickup",
                context,
            )
            await Bot.change_presence(
                activity=discord.Game(
                    name="Pickup ("
                    + str(len(PLAYERS))
                    + "/"
                    + str(sizeOfGame)
                    + ") "
                    + cmdprefix
                    + "add"
                )
            )

        # each time someone adds, we need to check to see if the pickup is full
        if len(PLAYERS) == sizeOfGame:
            # start the pickup
            reset = await go_go_gadget_pickup(context)
            if reset:
                # Reset so we can play another one
                CHOSEN_MAP = []
                MAP_PICKS = {}
                PLAYERS = []
                STARTER = []
                PICKUP_RUNNING = False
                VOTE_FOR_MAPS = True


# rcon
@Bot.command(
    name="rcon",
    description="Executes the command you specify in the server, using Remote CONnection",
    brief="RCON relay to the set server",
    aliases=[
        "remote_connection",
    ],
)
async def _rcon(context):
    global rcon, rconPW, server, server_address
    # admin command
    member = server.get_member(context.author.id)
    if await user_has_access(member):
        message = context.message.content.split()
        # make sure the user provided a value
        if len(message) > 1:
            # do not let them destroy the server
            if await command_will_fubar_server(message[1]):
                await send_emb_message_to_user(
                    0x00FF00,
                    "That command is not allowed",
                    context,
                )
                return
            # everything else is fair game :: send whatever command the user provided
            try:
                rcon_command = str(" ".join([opt for opt in message[1:]])).encode('utf-8')
                rcon = valve.rcon.RCON(server_address, rconPW)
                rcon.connect()
                rcon.authenticate()
                resp = rcon.execute(rcon_command)
                print(
                    "LOG MESSAGE: RCON command <"
                    + str(rcon_command)
                    + "> response received\n\t"
                    + str(resp)
                    + "\nAt time "
                    + time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
                )
            except Exception as inst:
                print(inst)
                pass
            await send_emb_message_to_user(
                0x00FF00,
                context.author.mention + " the RCON command has been executed",
                context,
            )
        else:
            await send_emb_message_to_user(
                0xFF0000,
                "You must provide a command and options. "
                + cmdprefix
                + "rcon ff_prematch 0",
                context,
            )
    else:
        await send_emb_message_to_user(
            0xFF0000,
            "You do not have access to this command",
            context,
        )


# Records
@Bot.command(
    name="records",
    description="Get a link to the All-time Records on ffpickup.com",
    brief="Get a link to the All-time Records",
    aliases=["alltime", "alltime_records", "best"],
)
async def _records(context):
    await send_emb_message_to_user(
        0xFFA500,
        "All-time Records (work in progress): http://parser.ffpickup.com/v2/records/",
        context,
    )


# Remove
@Bot.command(
    name="remove",
    description="Remove yourself or the specified player (Admin only) and any map nomination they may have from the pickup",
    brief="Removes the user from the pickup",
    aliases=["removeme", "remove_me", "removeplayer", "remove_player"],
)
async def _remove(context):
    global MAP_PICKS, PLAYERS, poolRole, sizeOfGame
    if await command_is_in_wrong_channel(context):
        return  # To avoid cluttering and confusion, the Bot only listens to one channel
    if not await pickup_is_running(context):
        return  # there must be an active pickup
    try:
        idleUser = context.message.mentions[0]
        # must be an admin to remove someone other than yourself
        if await user_has_access(context.author):
            if idleUser in PLAYERS:
                PLAYERS.remove(idleUser)  # remove from players list
                MAP_PICKS.pop(
                    idleUser, None
                )  # remove this players nomination if they had one
                try:
                    await context.message.mentions[0].remove_roles(poolRole)
                except Exception:
                    pass
                await send_emb_message_to_channel(
                    0x00FF00,
                    context.message.mentions[0].mention
                    + " you have been removed from the pickup by "
                    + context.author.mention
                    + " (admin)",
                    context,
                )
                await Bot.change_presence(
                    activity=discord.Game(
                        name="Pickup ("
                        + str(len(PLAYERS))
                        + "/"
                        + str(sizeOfGame)
                        + ") "
                        + cmdprefix
                        + "add"
                    )
                )
            else:
                await send_emb_message_to_channel(
                    0x00FF00,
                    context.author.mention + " that user is not added to the pickup",
                    context,
                )
        else:
            await send_emb_message_to_channel(
                0xFF0000,
                context.author.mention + " you do not have access to this command",
                context,
            )
    except (IndexError):
        # no user mentioned so check if the author is in pickup
        idleUser = context.author
        if idleUser in PLAYERS:
            PLAYERS.remove(idleUser)  # remove from players list
            MAP_PICKS.pop(
                idleUser, None
            )  # remove this players nomination if they had one
            try:
                await idleUser.remove_roles(poolRole)
            except Exception:
                pass
            await send_emb_message_to_channel(
                0x00FF00,
                context.author.mention + " you have been removed from the pickup",
                context,
            )
            await Bot.change_presence(
                activity=discord.Game(
                    name="Pickup ("
                    + str(len(PLAYERS))
                    + "/"
                    + str(sizeOfGame)
                    + ") "
                    + cmdprefix
                    + "add"
                )
            )
        else:
            await send_emb_message_to_channel(
                0x00FF00,
                context.author.mention + " no worries, you never even added",
                context,
            )


# Remove Nomination
@Bot.command(
    name="removenom",
    description="Allows an admin to remove a map nominate from the list",
    brief="Removes the specified map nomination from the pickup",
    aliases=[
        "removenomination",
        "remove_nom",
        "remove_nomination",
        "vetonomination",
        "veto_nom",
        "veto_nomination",
    ],
)
async def _removenom(context):
    global MAP_PICKS
    if await command_is_in_wrong_channel(context):
        return  # To avoid cluttering and confusion, the Bot only listens to one channel
    if not await pickup_is_running(context):
        return  # there must be an active pickup
    # must be an admin to remove a map nomination
    if await user_has_access(context.author):
        message = context.message.content.split()
        # make sure the user provided a map
        if len(message) > 1:
            # check to see if the provided map is an alias
            atom = await mapname_is_valid(message[1])
            if atom != "INVALID":
                # check to see if someone has nominated this map
                for author, mp in MAP_PICKS.items():
                    if atom == str(mp):
                        # remove this nomination
                        MAP_PICKS.pop(author, None)
                        await send_emb_message_to_channel(
                            0x00FF00,
                            atom
                            + " has been removed from the nominations by "
                            + context.author.mention
                            + " (admin)",
                            context,
                        )
                        return
                # no match found
                await send_emb_message_to_channel(
                    0xFF0000, atom + " is not a nominated map currently", context
                )
            else:
                await send_emb_message_to_channel(
                    0xFF0000,
                    context.author.mention
                    + " that mapname is not a valid map. Please make another selection",
                    context,
                )
        else:
            await send_emb_message_to_channel(
                0xFF0000,
                context.author.mention
                + " you must provide a mapname. "
                + cmdprefix
                + "removenom mapname",
                context,
            )
    else:  # not an admin
        await send_emb_message_to_channel(
            0xFF0000,
            context.author.mention + " you do not have access to this command",
            context,
        )


# Setmode
@Bot.command(
    name="setmode",
    description="Allows an admin to change the way the map is picked. Options are random or vote",
    brief="Change the way the map is picked",
    aliases=["changemode", "change_mode", "set_mode"],
)
async def _setmode(context):
    global STARTER, VOTE_FOR_MAPS
    if await command_is_in_wrong_channel(context):
        return  # To avoid cluttering and confusion, the Bot only listens to one channel
    if not await pickup_is_running(context):
        return  # there must be an active pickup
    # admin command
    if await user_has_access(context.author):
        # make sure this admin owns this pickup
        if STARTER[0] == context.author:
            message = context.message.content.split()
            try:
                m = message[1]
                if m.startswith("random"):
                    VOTE_FOR_MAPS = False
                    await send_emb_message_to_channel(
                        0x00FF00,
                        "Map Selection has successfully been changed to randomly select from the list of nominations",
                        context,
                    )
                elif m.startswith("vote"):
                    VOTE_FOR_MAPS = True
                    await send_emb_message_to_channel(
                        0x00FF00,
                        "Map Selection has successfully been changed to call a player vote",
                        context,
                    )
                else:
                    await send_emb_message_to_channel(
                        0xFF0000,
                        context.author.mention
                        + " that is not a valid mode you must type "
                        + cmdprefix
                        + "setmode random or "
                        + cmdprefix
                        + "setmode vote",
                        context,
                    )
                    return
            except (IndexError):
                await send_emb_message_to_channel(
                    0xFF0000,
                    context.author.mention
                    + " to change the map selection mode you must type "
                    + cmdprefix
                    + "setmode random or "
                    + cmdprefix
                    + "setmode vote",
                    context,
                )
                return
        else:
            await send_emb_message_to_channel(
                0xFF0000,
                context.author.mention
                + " sorry, this pickup does not belong to you, it belongs to "
                + STARTER[0].mention,
                context,
            )
    else:
        await send_emb_message_to_channel(
            0xFF0000,
            context.author.mention + " you do not have access to this command",
            context,
        )


# Setserver
@Bot.command(
    name="setserver",
    description="Change the server the pickup will be played on (Game Starter Only)",
    brief="Change the server information",
    aliases=["changeserver", "change_server", "set_server"],
)
async def _setserver(context):
    global database, server_address, serverID, serverPW, rcon, rconPW, STARTER
    if await command_is_in_wrong_channel(context):
        return  # To avoid cluttering and confusion, the Bot only listens to one channel
    if not await pickup_is_running(context):
        return  # there must be an active pickup
    # admin command
    if await user_has_access(context.author):
        # make sure this admin owns this pickup
        if STARTER[0] == context.author:
            message = context.message.content.split()
            if len(message) > 2:
                cursor = None
                # switch on flag and search the MongoDB for a document that contains that op:data
                op = message[1]
                data = message[2]
                if op == "name":
                    cursor = database.servers.find({"names": data})
                elif op == "server":
                    cursor = database.servers.find({"serverid": data})
                # TODO: Add an option to supply a server in the command
                # check for a match
                if cursor is not None and cursor.count() > 0:
                    for doc in cursor:
                        # doc is a dict
                        serverID = doc["serverid"]
                        serverPW = doc["passwd"]
                        rconPW = doc["rcon"]
                        server_address = (serverID[:-6], 27015)
                        # reset rcon to our new RCON connection
                        rcon = valve.rcon.RCON(server_address, rconPW)
                        rcon.connect()
                        rcon.authenticate()
                        await send_emb_message_to_user(
                            0x00FF00,
                            context.author.mention
                            + " changing server\n\nServerID: "
                            + serverID
                            + "\n\nServer Address: "
                            + str(server_address)
                            + "\n\nPassword: "
                            + serverPW
                            + "\n\nRCON: "
                            + rconPW,
                            context,
                        )
                else:
                    await send_emb_message_to_channel(
                        0xFF0000,
                        context.author.mention
                        + " I am sorry, I did not find a server matching "
                        + op
                        + " = "
                        + data
                        + "\n\nPlease try again",
                        context,
                    )
            else:
                await send_emb_message_to_channel(
                    0xFF0000,
                    context.author.mention
                    + "\n\nThat is not how you use this command, options are either:\n"
                    + cmdprefix
                    + "setserver name serverAlias\n"
                    + cmdprefix
                    + "setserver serverID "
                    + serverPattern
                    + "\n\nPlease try again",
                    context,
                )
        else:
            await send_emb_message_to_channel(
                0xFF0000,
                context.author.mention
                + " sorry, this pickup does not belong to you, it belongs to "
                + STARTER[0].mention,
                context,
            )
    else:
        await send_emb_message_to_channel(
            0xFF0000,
            context.author.mention + " you do not have access to this command",
            context,
        )


# Sendinfo
@Bot.command(
    name="sendinfo",
    description="Sends the server IP and password via direct message",
    brief="Send server info via DM",
    aliases=["send_info"],
)
async def _sendinfo(context):
    global serverID, serverPW
    if await command_is_in_wrong_channel(context):
        return  # To avoid cluttering and confusion, the Bot only listens to one channel
    await send_emb_message_to_user(
        0x00FF00, "steam://connect/" + serverID + "/" + serverPW, context
    )


# Teams
@Bot.command(
    name="teams",
    description="Displays all of the members in the current pickup",
    brief="Display current pickup info",
    aliases=["game_info", "gameinfo"],
)
async def _teams(context):
    global PLAYERS
    if await command_is_in_wrong_channel(context):
        return  # To avoid cluttering and confusion, the Bot only listens to one channel
    if not await pickup_is_running(context):
        return  # there must be an active pickup
    if len(PLAYERS) < 1:
        await send_emb_message_to_channel(
            0x00FF00,
            "The pickup is empty right now. " + cmdprefix + "add to join",
            context,
        )
    elif len(PLAYERS) > 0:
        plyrStr = "\n".join([p.mention for p in PLAYERS])
        await send_emb_message_to_channel(0x00FF00, "Players:\n" + plyrStr, context)


# Transfer
@Bot.command(
    name="transfer",
    description="Give your pickup to another admin (Game Starter) or take possession of another admins pickup (All Other Admins)",
    brief="Transfer the current pickup to/from another admin",
    aliases=["give", "take"],
)
async def _transfer(context):
    global PLAYERS, STARTER, sizeOfGame
    if await command_is_in_wrong_channel(context):
        return  # To avoid cluttering and confusion, the Bot only listens to one channel
    if not await pickup_is_running(context):
        return  # there must be an active pickup
    if len(PLAYERS) == sizeOfGame:
        await send_emb_message_to_channel(
            0xFF0000,
            context.author.mention
            + " the pickup is full",
            context,
        )
        return # pickup cannot be full, bot will handle things if it is
    # admin command
    if await user_has_access(context.author):
        # does this admin own this pickup
        if STARTER[0] == context.author:
            # check for a pick and catch it if they didn't mention an available player
            try:
                newCap = context.message.mentions[0]
                # do not transfer your own pickup to yourself
                if newCap != STARTER[0]:
                    # verify the mentioned user is also an admin
                    if await user_has_access(newCap):
                        STARTER.clear()
                        STARTER.append(newCap)
                        await send_emb_message_to_channel(
                            0x00FF00,
                            context.author.mention
                            + " your pickup has successfully been transferred to "
                            + newCap.mention,
                            context,
                        )
                    else:
                        await send_emb_message_to_channel(
                            0xFF0000,
                            context.author.mention
                            + " you may only transfer your pickup to another admin",
                            context,
                        )
                else:
                    await send_emb_message_to_channel(
                        0xFF0000,
                        context.author.mention + " you already own this pickup",
                        context,
                    )
            except (IndexError):
                await send_emb_message_to_channel(
                    0xFF0000,
                    context.author.mention
                    + " you must type "
                    + cmdprefix
                    + "transfer @nameOfAdmin to transfer your pickup.",
                    context,
                )
                return  # break out if they did not specify a user
        else:  # someone who does not own pickup is trying to transfer
            try:
                # sometimes we forget who owns the pickup and try to transfer someone else's pickup
                # we can catch this by checking for a mention AFTER verifying author is not starter (done above)
                newCap = context.message.mentions[0]
                await send_emb_message_to_channel(
                    0xFF0000,
                    context.author.mention
                    + " you may only transfer your own pickup to another player",
                    context,
                )
                return  # break out if they accidentally specify a user
            except (IndexError):
                # they did not mention a user therefore they must be trying to take over a pickup
                if not await check_for_veto(cmdprefix + "transfer", context):
                    await send_emb_message_to_channel(
                        0x00FF00,
                        context.author.mention
                        + " you have successfully taken possession of "
                        + STARTER[0].mention
                        + " pickup",
                        context,
                    )
                    STARTER.clear()
                    STARTER.append(context.author)
                else:
                    await send_emb_message_to_channel(
                        0xFF0000,
                        STARTER[0].mention + " has vetoed the transfer",
                        context,
                    )
    else:
        await send_emb_message_to_channel(
            0xFF0000,
            context.author.mention + " you do not have access to this command",
            context,
        )


# Unban
@Bot.command(
    name="unban",
    description="Remove a ban for the specified user from the database and grant them access once more",
    brief="Unban a player",
    aliases=["del_ban", "delban", "un_ban", "remove_ban", "removeban"],
)
async def _unban(context):
    global bannedChannelID, database, dbclient
    if await command_is_in_wrong_channel(context):
        return  # To avoid cluttering and confusion, the Bot only listens to one channel
    message = context.message.content.split()
    # admin command
    if await user_has_access(context.author):
        try:
            banned = context.message.mentions[0]
        except (IndexError):
            await send_emb_message_to_channel(
                0xFF0000,
                "That is not a valid user, you must @mention the player\n\n"
                + cmdprefix
                + "unban @user the reason why you are removing this ban",
                context,
            )
            return
    else:
        await send_emb_message_to_channel(
            0xFF0000,
            context.author.mention + " you do not have access to this command",
            context,
        )
        return
    if len(message) >= 3:
        await set_database()
        reason = " ".join(message[2:])

        # delete the ban from the MongoDB
        database.banned.delete_one({"userid": banned.id})

        # give user back access
        member = server.get_member(banned.id)
        try:
            await member.remove_roles(timeoutRole)
            await asyncio.sleep(2)
            await member.add_roles(accessRole)
            await member.add_roles(probationRole)
        except Exception:
            pass

        # notify the admins
        emb = discord.Embed(
            description="The ban for user "
            + member.mention
            + " has been removed by "
            + context.author.mention
            + " (Admin)\nReason given: "
            + reason
            + "\n\nNOTE: This action has been logged",
            colour=0x00FF00,
        )
        emb.set_author(name=Bot.user.name, icon_url=Bot.user.avatar_url)
        await server.get_channel(bannedChannelID).send(embed=emb)
        await server.get_channel(adminChannelID).send(embed=emb)
        # notify the user
        emb = discord.Embed(
            description="Your ban has been removed by "
            + context.author.mention
            + " (Admin)\nReason given: "
            + reason
            + "\n\nNOTE: This action has been logged",
            colour=0x00FF00,
        )
        emb.set_author(name=Bot.user.name, icon_url=Bot.user.avatar_url)
        await member.send(embed=emb)
        print(
            "LOG MESSAGE: The ban for Player: "
            + str(member)
            + " has been removed by "
            + context.author.name
            + " (Admin) for reason: "
            + reason
        )
        dbclient.close()
    else:
        await send_emb_message_to_channel(
            0xFF0000,
            "You need to provide a reason for why you are removing this ban early\n\n"
            + cmdprefix
            + "unban @user the reason why you are removing this ban early",
            context,
        )


# Unsubscribe
@Bot.command(
    name="unsubscribe",
    description="Allows users to leave the notification group, which removes them from the channel",
    brief="Leave the pickup channel",
    aliases=["unpug", "unsub"],
)
async def _unsubscribe(context):
    global accessRole, newPlayerRole
    if await command_is_in_wrong_channel(context):
        return  # To avoid cluttering and confusion, the Bot only listens to one channel
    if accessRole is not None:
        try:
            await context.author.remove_roles(accessRole)
            await send_emb_message_to_user(
                0x00FF00,
                "Successfully removed role {0}".format(accessRole.name),
                context,
            )
            await context.author.remove_roles(newPlayerRole)
            await send_emb_message_to_user(
                0x00FF00,
                "Successfully removed role {0}".format(newPlayerRole.name),
                context,
            )
        except (discord.Forbidden, discord.HTTPException):
            pass
    else:  # role is None - this is typically caused by playerRoleID not matching any roles in the server
        print(
            "ERROR MESSAGE: Something went wrong at "
            + str(time.time())
            + "\nDue to unsubscribe => role is None\n\nCheck playerRoleID is in server role id"
        )
        await send_emb_message_to_user(
            0xFF0000,
            "Something went wrong\nDue to unsubscribe => role is None\n\nCheck playerRoleID is in server role id\nPlease contact an admin",
            context,
        )


# make bot commands case insensitive
@Bot.event
async def on_message(message):
    # No bot for bad users
    try:
        if await author_is_in_timeout(message):
            return
    except AttributeError:
        return
    message.content = message.content.lower()
    await Bot.process_commands(message)


# print and change presence when ready
@Bot.event
async def on_ready():
    global adminRole, adminRoleID, accessRole, newPlayerRole, newPlayerRoleID, playerRoleID, poolRole, poolRoleID, probationRole, probationRoleID, server, timeoutRole, timeoutRoleID
    await Bot.wait_until_ready()
    await Bot.change_presence(activity=Game(name="Ready"))
    print("Pickup Game Bot for Discord - Version 2.0")
    print("Logged in as: " + Bot.user.name)
    print("Id: " + str(Bot.user.id))
    server = Bot.get_guild(discordServerID)
    adminRole = discord.utils.get(server.roles, id=adminRoleID)
    accessRole = discord.utils.get(server.roles, id=playerRoleID)
    newPlayerRole = discord.utils.get(server.roles, id=newPlayerRoleID)
    poolRole = discord.utils.get(server.roles, id=poolRoleID)
    probationRole = discord.utils.get(server.roles, id=probationRoleID)
    timeoutRole = discord.utils.get(server.roles, id=timeoutRoleID)
    await remove_everyone_from_pool_role_post_restart()


# keep track of any banned users who re-join the server
@Bot.event
async def on_member_join(member):
    # connect to MongoDB
    await set_database()
    collection = database["banned"]
    cursor = collection.find({})
    for document in cursor:
        if member.id == document.get("userid"):
            # remove access to the channel
            try:
                await member.add_roles(timeoutRole)
                await asyncio.sleep(2)
                await member.remove_roles(accessRole)
            except (discord.Forbidden, discord.HTTPException):
                pass


while True:
    if numRestarts >= 4:
        subprocess.call(["../runBot.sh"])
    try:
        client.loop.run_until_complete(Bot.start(token))
    except Exception:
        numRestarts += 1
        client.loop.run_until_complete(Bot.logout())
        for task in asyncio.Task.all_tasks(loop=client.loop):
            if task.done():
                task.exception()
                continue
            task.cancel()
            try:
                client.loop.run_until_complete(
                    asyncio.wait_for(task, 5, loop=client.loop)
                )
                task.exception()
            except asyncio.InvalidStateError:
                pass
            except asyncio.TimeoutError:
                pass
            except asyncio.CancelledError:
                pass
            print(
                "LOGGER: Bot restarting - At time "
                + time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
            )
            client = discord.Client(loop=client.loop)