import random
import math
import datetime
import asyncio
import discord

from shutil import copyfile

from funcs import logThis, replaceMultiple
from .blackjackDraw import DrawBlackjack

class Blackjack():
    def __init__(self,bot):
        self.bot = bot
        self.draw = DrawBlackjack(bot)

    # Shuffles the blackjack cards
    def blackjackShuffle(self, decks, channel):
        logThis("Shuffling the blackjack deck")

        with open("resources/games/deckofCards.txt","r") as f:
            deck = f.read()

        allDecks = deck.split("\n") * decks
        random.shuffle(allDecks)

        self.bot.database["blackjack cards"].update_one({"_id":channel},{"$set":{"_id":channel,"cards":allDecks}},upsert=True)

        # Creates hilo file
        logThis("creating hilo doc for "+channel)
        data = 0
        self.bot.database["hilo"].update_one({"_id":channel},{"$set":{"_id":channel,"hilo":data}},upsert=True)

        return

    # Calculates the value of a blackjack hand
    def calcHandValue(self, hand : list):
        logThis("Calculating hand value")
        values = []
        values.append(0)

        for card in hand:
            cardValue = card[0]
            cardValue = replaceMultiple(cardValue,["0","k","q","j"],"10")
            if cardValue == "a":
                length = len(values)
                for x in range(length):
                    values.append(values[x] + 11)
                    values[x] += 1
            else:
                for x in range(len(values)):
                    values[x] += int(cardValue)

        values.sort()

        handValue = values[0]
        for value in values:
            if value <= 21:
                handValue = value

        logThis("Calculated "+str(hand)+" to be "+str(handValue))

        return handValue

    # Draws a card from the deck
    def drawCard(self, channel):
        logThis("drawing a card")

        drawnCard = self.bot.database["blackjack cards"].find_one({"_id":channel})["cards"][0]
        self.bot.database["blackjack cards"].update_one({"_id":channel},{"$pop":{"cards":-1}})
        value = self.calcHandValue([drawnCard])

        if value <= 6:
            self.bot.database["hilo"].update_one({"_id":channel},{"$inc":{"hilo":1}})
        elif value >= 10:
            self.bot.database["hilo"].update_one({"_id":channel},{"$inc":{"hilo":-1}})

        return drawnCard

    # Dealer draws a card and checks if they should draw another one
    def dealerDraw(self,channel):
        game = self.bot.database["blackjack games"].find_one({"_id":channel})

        done = False
        dealerHand = game["dealer hand"]

        if self.calcHandValue(dealerHand) < 17:
            dealerHand.append(self.drawCard(channel))
            self.bot.database["blackjack games"].update_one({"_id":channel},{"$set":{"dealer hand":dealerHand}})
        else:
            done = True

        if self.calcHandValue(dealerHand) > 21:
            self.bot.database["blackjack games"].update_one({"_id":channel},{"$set":{"dealer busted":True}})

        return done

    # Goes to the next round and calculates some stuff
    def blackjackContinue(self, channel):
        logThis("Continuing blackjack game")
        game = self.bot.database["blackjack games"].find_one({"_id":channel})

        done = False

        self.bot.database["blackjack games"].update_one({"_id":channel},{"$inc":{"round":1}})

        allStanding = True
        preAllStanding = True
        message = "All players are standing. The dealer now shows his cards and draws."

        if game["all standing"]:
            logThis("All are standing")

            done = self.dealerDraw(channel)
            message = "The dealer draws a card."

            game = self.bot.database["blackjack games"].find_one({"_id":channel})

        logThis("Testing if all are standing")
        for user in game["user hands"]:
            try:
                newUser, allStanding, preAllStanding = self.testIfStanding(game["user hands"][user],allStanding,preAllStanding,True)
                self.bot.database["blackjack games"].update_one({"_id":channel},{"$set":{"user hands."+user:newUser}})
            except:
                logThis("Error in testing if all are standing (error code 1331)")

        if allStanding:
            self.bot.database["blackjack games"].update_one({"_id":channel},{"$set":{"all standing":True}})

        try:
            self.draw.drawImage(channel)
        except:
            logThis("Error drawing blackjack table (error code 1340)")

        if allStanding:
            if done == False:
                return message, True, done
            else:
                return "The dealer is done drawing cards", True, done
        elif preAllStanding:
            return "", True, done
        else:
            if game["round"] == 1:
                firstRoundMessage = ". You can also double down with \"!blackjack double\" or split with \"!blackjack split\""
            else:
                firstRoundMessage = ""
            return "You have 2 minutes to either hit or stand with \"!blackjack hit\" or \"!blackjack stand\""+firstRoundMessage+". It's assumed you're standing if you don't make a choice.", False, done

    def testIfStanding(self, hand,allStanding,preAllStanding,topLevel):
        if hand["hit"] == False:
            hand["standing"] = True

        if hand["standing"] == False:
            allStanding = False

            if self.calcHandValue(hand["hand"]) >= 21 or hand["doubled"]:
                hand["standing"] = True
            else:
                preAllStanding = False

        hand["hit"] = False

        if topLevel:
            if hand["split"] >= 1:
                hand["other hand"], allStanding, preAllStanding = self.testIfStanding(hand["other hand"],allStanding,preAllStanding,False)
            if hand["split"] >= 2:
                hand["third hand"], allStanding, preAllStanding = self.testIfStanding(hand["third hand"],allStanding,preAllStanding,False)
            if hand["split"] >= 3:
                hand["fourth hand"], allStanding, preAllStanding = self.testIfStanding(hand["fourth hand"],allStanding,preAllStanding,False)

        return hand, allStanding, preAllStanding


    # When players try to hit
    def blackjackHit(self,channel,user,handNumber = 0):
        game = self.bot.database["blackjack games"].find_one({"_id":channel})

        if user in game["user hands"]:

            hand, handNumber = self.getHandNumber(game["user hands"][user],handNumber)

            if hand != None:
                if game["round"] > 0:
                    if hand["hit"] == False:
                        if hand["standing"] == False:
                            hand["hand"].append(self.drawCard(channel))
                            hand["hit"] = True

                            handValue = self.calcHandValue(hand["hand"])

                            if handValue > 21:
                                hand["busted"] = True

                            if handNumber == 2:
                                self.bot.database["blackjack games"].update_one({"_id":channel},
                                    {"$set":{"user hands."+user+".other hand":hand}})
                            elif handNumber == 3:
                                self.bot.database["blackjack games"].update_one({"_id":channel},
                                    {"$set":{"user hands."+user+".third hand":hand}})
                            elif handNumber == 4:
                                self.bot.database["blackjack games"].update_one({"_id":channel},
                                    {"$set":{"user hands."+user+".fourth hand":hand}})
                            else:
                                self.bot.database["blackjack games"].update_one({"_id":channel},
                                    {"$set":{"user hands."+user:hand}})

                            response = "accept"
                            roundDone = self.isRoundDone(self.bot.database["blackjack games"].find_one({"_id":channel}))

                            return response + str(roundDone)[0] + str(game["round"])
                        else:
                            logThis(user+" is already standing")
                            return "You can't hit when you're standing"
                    else:
                        logThis(user+" has already hit this round")
                        return "You've already hit this round"
                else:
                    logThis(user+" tried to hit on the 0th round")
                    return "You can't hit before you see your cards"
            else:
                logThis(user+" didn't specify a hand")
                return "You need to specify a hand"
        else:
            logThis(user+" tried to hit without being in the game")
            return "You have to enter the game before you can hit"


    # When players try to double down
    def blackjackDouble(self,channel,user,handNumber = 0):
        game = self.bot.database["blackjack games"].find_one({"_id":channel})

        if user in game["user hands"]:
            hand, handNumber = self.getHandNumber(game["user hands"][user],handNumber)

            if hand != None:
                if game["round"] > 0:
                    if hand["hit"] == False:
                        if hand["standing"] == False:
                            if len(hand["hand"]) == 2:
                                bet = hand["bet"]
                                if self.bot.money.checkBalance(user) >= bet:
                                    self.bot.money.addMoney(user,-1 * bet)

                                    hand["hand"].append(self.drawCard(channel))
                                    hand["hit"] = True
                                    hand["doubled"] = True
                                    hand["bet"] += bet

                                    handValue = self.calcHandValue(hand["hand"])


                                    if handValue > 21:
                                        hand["busted"] = True

                                    if handNumber == 2:
                                        self.bot.database["blackjack games"].update_one({"_id":channel},
                                            {"$set":{"user hands."+user+".other hand":hand}})
                                    elif handNumber == 3:
                                        self.bot.database["blackjack games"].update_one({"_id":channel},
                                            {"$set":{"user hands."+user+".third hand":hand}})
                                    elif handNumber == 4:
                                        self.bot.database["blackjack games"].update_one({"_id":channel},
                                            {"$set":{"user hands."+user+".fourth hand":hand}})
                                    else:
                                        self.bot.database["blackjack games"].update_one({"_id":channel},
                                            {"$set":{"user hands."+user:hand}})

                                    roundDone = self.isRoundDone(self.bot.database["blackjack games"].find_one({"_id":channel}))

                                    return "Adding another "+str(bet)+" GwendoBucks to "+self.bot.funcs.getName(user)+"'s bet and drawing another card.",str(roundDone)[0] + str(game["round"])
                                else:
                                    logThis(user+" doesn't have enough GwendoBucks")
                                    return "You don't have enough GwendoBucks",""
                            else:
                                logThis(user+" tried to double on round "+str(game["round"]))
                                return "You can only double down on the first round",""
                        else:
                            logThis(user+" is already standing")
                            return "You can't double when you're standing",""
                    else:
                        logThis(user+" has already hit this round")
                        return "You've already hit this round",""
                else:
                    logThis(user+" tried to double on the 0th round")
                    return "You can't double down before you see your cards",""
            else:
                logThis(user+" didn't specify a hand")
                return "You need to specify which hand"
        else:
            logThis(user+" tried to double without being in the game")
            return "You can't double when you're not in the game",""

    # When players try to stand
    def blackjackStand(self,channel,user,handNumber = 0):
        game = self.bot.database["blackjack games"].find_one({"_id":channel})

        if user in game["user hands"]:

            hand, handNumber = self.getHandNumber(game["user hands"][user],handNumber)

            if hand != None:
                if game["round"] > 0:
                    if hand["hit"] == False:
                        if hand["standing"] == False:
                            hand["standing"] = True

                            if handNumber == 2:
                                self.bot.database["blackjack games"].update_one({"_id":channel},
                                    {"$set":{"user hands."+user+".other hand":hand}})
                            elif handNumber == 3:
                                self.bot.database["blackjack games"].update_one({"_id":channel},
                                    {"$set":{"user hands."+user+".third hand":hand}})
                            elif handNumber == 4:
                                self.bot.database["blackjack games"].update_one({"_id":channel},
                                    {"$set":{"user hands."+user+".fourth hand":hand}})
                            else:
                                self.bot.database["blackjack games"].update_one({"_id":channel},
                                    {"$set":{"user hands."+user:hand}})

                            response = "accept"
                            roundDone = self.isRoundDone(self.bot.database["blackjack games"].find_one({"_id":channel}))

                            return response + str(roundDone)[0] + str(game["round"])
                        else:
                            logThis(user+" is already standing")
                            return "You're already standing"
                    else:
                        logThis(user+" has already hit this round")
                        return "You've already hit this round"
                else:
                    logThis(user+" tried to stand on the first round")
                    return "You can't stand before you see your cards"
            else:
                logThis(user+" didn't specify a hand")
                return "You need to specify which hand"
        else:
            logThis(user+" tried to stand without being in the game")
            return "You have to enter the game before you can stand"

    # When players try to split
    def blackjackSplit(self,channel,user,handNumber = 0):
        game = self.bot.database["blackjack games"].find_one({"_id":channel})

        if game["user hands"][user]["split"] == 0:
            hand = game["user hands"][user]
            newHand = game["user hands"][user]["other hand"]
            handNumber = 0
            otherHand = 2
        else:
            if handNumber != 0:
                if handNumber == 1:
                    hand = game["user hands"][user]
                elif handNumber == 2:
                    hand = game["user hands"][user]["other hand"]
                elif handNumber == 3:
                    hand = game["user hands"][user]["third hand"]
                else:
                    logThis(user+" tried to hit without specifying which hand")
                    return "You have to specify the hand you're hitting with."

                if game["user hands"][user]["split"] == 1:
                    newHand = game["user hands"][user]["third hand"]
                    otherHand = 3
                else:
                    newHand = game["user hands"][user]["fourth hand"]
                    otherHand = 4
            else:
                logThis(user+" tried to split without specifying which hand")
                return "You have to specify the hand you're splitting.",""

        if game["user hands"][user]["split"] < 3:
            if game["round"] != 0:
                if hand["hit"] == False:
                    if hand["standing"] == False:
                        if len(hand["hand"]) == 2:
                            firstCard = self.calcHandValue([hand["hand"][0]])
                            secondCard = self.calcHandValue([hand["hand"][1]])
                            if firstCard == secondCard:
                                bet = hand["bet"]
                                if self.bot.money.checkBalance(user) >= bet:
                                    self.bot.money.addMoney(user,-1 * bet)

                                    hand["hit"] = True
                                    newHand["hit"] = True

                                    newHand = {
                                            "hand":[],"bet":0,"standing":False,"busted":False,
                                            "blackjack":False,"hit":True,"doubled":False}

                                    newHand["bet"] = hand["bet"]

                                    newHand["hand"].append(hand["hand"].pop(1))
                                    newHand["hand"].append(self.drawCard(channel))
                                    hand["hand"].append(self.drawCard(channel))

                                    handValue = self.calcHandValue(hand["hand"])
                                    otherHandValue = self.calcHandValue(newHand["hand"])
                                    if handValue > 21:
                                        hand["busted"] = True
                                    elif handValue == 21:
                                        hand["blackjack"] = True

                                    if otherHandValue > 21:
                                        newHand["busted"] = True
                                    elif otherHandValue == 21:
                                        newHand["blackjack"] = True

                                    if handNumber == 2:
                                        self.bot.database["blackjack games"].update_one({"_id":channel},
                                            {"$set":{"user hands."+user+".other hand":hand}})
                                    elif handNumber == 3:
                                        self.bot.database["blackjack games"].update_one({"_id":channel},
                                            {"$set":{"user hands."+user+".third hand":hand}})
                                    else:
                                        self.bot.database["blackjack games"].update_one({"_id":channel},
                                            {"$set":{"user hands."+user:hand}})

                                    if otherHand == 3:
                                        self.bot.database["blackjack games"].update_one({"_id":channel},
                                            {"$set":{"user hands."+user+".third hand":newHand}})
                                    elif otherHand == 4:
                                        self.bot.database["blackjack games"].update_one({"_id":channel},
                                            {"$set":{"user hands."+user+".fourth hand":newHand}})
                                    else:
                                        self.bot.database["blackjack games"].update_one({"_id":channel},
                                            {"$set":{"user hands."+user+".other hand":newHand}})

                                    self.bot.database["blackjack games"].update_one({"_id":channel},
                                        {"$inc":{"user hands."+user+".split":1}})

                                    roundDone = self.isRoundDone(self.bot.database["blackjack games"].find_one({"_id":channel}))

                                    return "Splitting "+self.bot.funcs.getName(user)+"'s hand into 2. Adding their original bet to the second hand. You can use \"!Blackjack hit/stand/double 1\" and \"!Blackjack hit/stand/double 2\" to play the different hands.",str(roundDone)[0] + str(game["round"])
                                else:
                                    logThis(user+" doesn't have enough GwendoBucks")
                                    return "You don't have enough GwendoBucks",""
                            else:
                                logThis(user+" tried to split 2 different cards")
                                return "Your cards need to have the same value to split",""
                        else:
                            logThis(user+" tried to split later than they could")
                            return "You can only split on the first round",""
                    else:
                        logThis(user+" is already standing")
                        return "You can't split when you're standing",""
                else:
                    logThis(user+" has already hit this round")
                    return "You've already hit this round",""
            else:
                logThis(user+" tried to split on the 0th round")
                return "You can't split before you see your cards",""
        else:
            logThis(user+" tried to split more than three times")
            return "You can only split 3 times",""

    # Player enters the game and draws a hand
    def blackjackPlayerDrawHand(self,channel,user,bet):
        game = self.bot.database["blackjack games"].find_one({"_id":channel})

        logThis(self.bot.funcs.getName(user)+" is trying to join the game in "+channel)

        if game != None:
            if user not in game["user hands"]:
                if len(game["user hands"]) < 5:
                    if game["round"] == 0:
                        if bet >= 0:
                            if self.bot.money.checkBalance(user) >= bet:
                                self.bot.money.addMoney(user,-1 * bet)
                                playerHand = [self.drawCard(channel),self.drawCard(channel)]

                                handValue = self.calcHandValue(playerHand)

                                if handValue == 21:
                                    blackjackHand = True
                                else:
                                    blackjackHand = False

                                newHand = {"hand":playerHand,
                                    "bet":bet,"standing":False,"busted":False,"blackjack":blackjackHand,"hit":True,
                                    "doubled":False,"split":0,"other hand":{},"third hand":{},"fourth hand":{}}
                                self.bot.database["blackjack games"].update_one({"_id":channel},
                                    {"$set":{"user hands."+user:newHand}})

                                logThis(self.bot.funcs.getName(user)+" entered the game")
                                return self.bot.funcs.getName(user)+" entered the game"
                            else:
                                logThis(user+" doesn't have enough GwendoBucks")
                                return "You don't have enough GwendoBucks to place that bet"
                        else:
                            logThis(user+" tried to bet a negative amount")
                            return "You can't bet a negative amount"
                    else:
                        logThis("The table is no longer open for bets")
                        return "The table is no longer open for bets"
                else:
                    logThis("There are already 5 players in the game.")
                    return "There's already a maximum of players at the table."
            else:
                logThis(user+" is already in the game")
                return "You've already entered this game"
        else:
            logThis("There is no game going on in "+channel)
            return "There is no game going on in this channel"

    # Starts a game of blackjack
    def blackjackStart(self,channel:str):
        game = self.bot.database["blackjack games"].find_one({"_id":channel})

        logThis("Trying to start a blackjack game in "+channel)

        if game == None:

            dealerHand = [self.drawCard(channel),self.drawCard(channel)]
            gameID = datetime.datetime.now().strftime('%Y%m%d%H%M%S')

            newGame = {"_id":channel,"dealer hand": dealerHand,"dealer busted":False,"dealer blackjack":False,"user hands": {},"all standing":False,"round":0,"gameID":gameID}

            if self.calcHandValue(dealerHand) == 21:
                newGame["dealer blackjack"] = True

            self.bot.database["blackjack games"].insert_one(newGame)

            copyfile("resources/games/blackjackTable.png","resources/games/blackjackTables/blackjackTable"+channel+".png")

            return "started"
        else:
            logThis("There is already a blackjack game going on in "+channel)
            return "There's already a blackjack game going on. Try again in a few minutes."

    # Ends the game and calculates winnings
    def blackjackFinish(self,channel):
        finalWinnings = "*Final Winnings:*\n"

        game = self.bot.database["blackjack games"].find_one({"_id":channel})

        dealerValue = self.calcHandValue(game["dealer hand"])
        dealerBlackjack = game["dealer blackjack"]
        dealerBusted = game["dealer busted"]

        try:
            for user in game["user hands"]:

                try:
                    winnings, netWinnings, reason = self.calcWinnings(game["user hands"][user],dealerValue,True,dealerBlackjack,dealerBusted)
                except:
                    logThis("Error calculating winnings for "+str(user)+" (error code 1312)")

                if winnings < 0:
                    if winnings == -1:
                        finalWinnings += self.bot.funcs.getName(user)+" lost "+str(-1 * winnings)+" GwendoBuck "+reason+"\n"
                    else:
                        finalWinnings += self.bot.funcs.getName(user)+" lost "+str(-1 * winnings)+" GwendoBucks "+reason+"\n"
                else:
                    if winnings == 1:
                        finalWinnings += self.bot.funcs.getName(user)+" won "+str(winnings)+" GwendoBuck "+reason+"\n"
                    else:
                        finalWinnings += self.bot.funcs.getName(user)+" won "+str(winnings)+" GwendoBucks "+reason+"\n"

                self.bot.money.addMoney(user,netWinnings)

        except:
            logThis("Error calculating winnings (error code 1311)")

        self.bot.database["blackjack games"].delete_one({"_id":channel})

        return finalWinnings


    def calcWinnings(self,hand, dealerValue, topLevel, dealerBlackjack, dealerBusted):
        logThis("Calculating winnings")
        reason = ""
        bet = hand["bet"]
        winnings = -1 * bet
        netWinnings = 0
        handValue = self.calcHandValue(hand["hand"])

        if hand["blackjack"] and dealerBlackjack == False:
            reason += "(blackjack)"
            winnings +=  math.floor(2.5 * bet)
            netWinnings +=  math.floor(2.5 * bet)
        elif dealerBlackjack:
            reason += "(dealer blackjack)"
        elif hand["busted"]:
            reason += "(busted)"
        else:
            if dealerBusted:
                reason = "(dealer busted)"
                winnings += 2 * bet
                netWinnings += 2 * bet
            elif handValue > dealerValue:
                winnings += 2 * bet
                netWinnings += 2 * bet
                reason = "(highest value)"
            elif handValue == dealerValue:
                reason = "(pushed)"
                winnings += bet
                netWinnings += bet
            else:
                reason = "(highest value)"

        if topLevel:
            if hand["split"] >= 1:
                winningsTemp, netWinningsTemp, reasonTemp = self.calcWinnings(hand["other hand"],dealerValue,False,dealerBlackjack,dealerBusted)
                winnings += winningsTemp
                netWinnings += netWinningsTemp
                reason += reasonTemp
            if hand["split"] >= 2:
                winningsTemp, netWinningsTemp, reasonTemp = self.calcWinnings(hand["third hand"],dealerValue,False,dealerBlackjack,dealerBusted)
                winnings += winningsTemp
                netWinnings += netWinningsTemp
                reason += reasonTemp
            if hand["split"] >= 3:
                winningsTemp, netWinningsTemp, reasonTemp = self.calcWinnings(hand["fourth hand"],dealerValue,False,dealerBlackjack,dealerBusted)
                winnings += winningsTemp
                netWinnings += netWinningsTemp
                reason += reasonTemp

        return winnings, netWinnings, reason

    def getHandNumber(self, user,handNumber):
        try:
            hand = None

            if user["split"] == 0:
                hand = user
                handNumber = 0
            else:
                if handNumber != 0:
                    if handNumber == 1:
                        hand = user
                    elif handNumber == 2:
                        hand = user["other hand"]
                    elif handNumber == 3:
                        hand = user["third hand"]
                    elif handNumber == 4:
                        hand = user["fourth hand"]

            return hand, handNumber
        except:
            logThis("Problem with getHandNumber() (error code 1322)")

    def isRoundDone(self,game):
        roundDone = True

        for person in game["user hands"].values():
            if person["hit"] == False and person["standing"] == False:
                roundDone = False

            if person["split"] > 0:
                if person["other hand"]["hit"] == False and person["other hand"]["standing"] == False:
                    roundDone = False

                if person["split"] > 1:
                    if person["third hand"]["hit"] == False and person["third hand"]["standing"] == False:
                        roundDone = False

                    if person["split"] > 2:
                        if person["fourth hand"]["hit"] == False and person["fourth hand"]["standing"] == False:
                            roundDone = False

        return roundDone

    # Loop of blackjack game rounds
    async def blackjackLoop(self,channel,gameRound,gameID):
        logThis("Loop "+str(gameRound),str(channel.id))

        with open("resources/games/oldImages/blackjack"+str(channel.id), "r") as f:
            oldImage = await channel.fetch_message(int(f.read()))

        new_message, allStanding, gamedone = self.blackjackContinue(str(channel.id))
        if new_message != "":
            logThis(new_message,str(channel.id))
            await channel.send(new_message)
        if gamedone == False:
            await oldImage.delete()
            oldImage = await channel.send(file = discord.File("resources/games/blackjackTables/blackjackTable"+str(channel.id)+".png"))
            with open("resources/games/oldImages/blackjack"+str(channel.id), "w") as f:
                f.write(str(oldImage.id))

        try:
            if allStanding:
                await asyncio.sleep(5)
            else:
                await asyncio.sleep(120)
        except:
            logThis("Loop "+str(gameRound)+" interrupted (error code 1321)")

        game = self.bot.database["blackjack games"].find_one({"_id":str(channel.id)})

        if game != None:
            realRound = game["round"]
            realGameID = game["gameID"]

            if gameRound == realRound and realGameID == gameID:
                if gamedone == False:
                    logThis("Loop "+str(gameRound)+" calling self.blackjackLoop()",str(channel.id))
                    await self.blackjackLoop(channel,gameRound+1,gameID)
                else:
                    try:
                        new_message = self.blackjackFinish(str(channel.id))
                    except:
                        logThis("Something fucked up (error code 1310)")
                    await channel.send(new_message)
            else:
                logThis("Ending loop on round "+str(gameRound),str(channel.id))
        else:
            logThis("Ending loop on round "+str(gameRound),str(channel.id))

    async def parseBlackjack(self,content, ctx):
        # Blackjack shuffle variables
        blackjackMinCards = 50
        blackjackDecks = 4

        channel = ctx.message.channel.id
        # Starts the game
        if content == "":
            cardsLeft = 0
            cards = self.bot.database["blackjack cards"].find_one({"_id":str(channel)})
            if cards != None:
                cardsLeft = len(cards["cards"])

            # Shuffles if not enough cards
            if cardsLeft < blackjackMinCards:
                self.blackjackShuffle(blackjackDecks,str(channel))
                logThis("Shuffling the blackjack deck...",str(channel))
                await ctx.send("Shuffling the deck...")

            new_message = self.blackjackStart(str(channel))
            if new_message == "started":

                new_message = "Blackjack game started. Use \"!blackjack bet [amount]\" to enter the game within the next 30 seconds."
                await ctx.send(new_message)
                oldImage = await ctx.send(file = discord.File("resources/games/blackjackTables/blackjackTable"+str(channel)+".png"))

                with open("resources/games/oldImages/blackjack"+str(channel), "w") as f:
                    f.write(str(oldImage.id))

                await asyncio.sleep(30)

                gamedone = False

                game = self.bot.database["blackjack games"].find_one({"_id":str(channel)})

                if len(game["user hands"]) == 0:
                    gamedone = True
                    await ctx.send("No one entered the game. Ending the game.")
                gameID = game["gameID"]

                # Loop of game rounds
                if gamedone == False:
                    logThis("!blackjack calling self.blackjackLoop()",str(channel))
                    await self.blackjackLoop(ctx.message.channel,1,gameID)
                else:
                    new_message = self.blackjackFinish(str(channel))
                    await ctx.send(new_message)
            else:
                await ctx.send(new_message)

        # Entering game and placing bet
        elif content.startswith("bet"):
            commands = content.split(" ")
            amount = int(commands[1])
            response = self.blackjackPlayerDrawHand(str(channel),"#"+str(ctx.message.author.id),amount)
            await ctx.send(response)

        # Hitting
        elif content.startswith("hit"):
            if content == "hit":
                response = self.blackjackHit(str(channel),"#"+str(ctx.message.author.id))
            else:
                commands = content.split(" ")
                try:
                    handNumber = int(commands[1])
                except:
                    handNumber = 0
                response = self.blackjackHit(str(channel),"#"+str(ctx.message.author.id),handNumber)

            if response.startswith("accept"):
                await ctx.message.add_reaction("👍")
                #try:
                if response[6] == "T":
                    gameID = self.bot.database["blackjack games"].find_one({"_id":str(channel)})["gameID"]
                    logThis("Hit calling self.blackjackLoop()",str(channel))
                    await self.blackjackLoop(ctx.message.channel,int(response[7:])+1,gameID)
                #except:
                #    logThis("Something fucked up (error code 1320)",str(channel))
            else:
                await ctx.send(response)


        # Standing
        elif content.startswith("stand"):
            if content == "hit":
                response = self.blackjackStand(str(channel),"#"+str(ctx.message.author.id))
            else:
                commands = content.split(" ")
                try:
                    handNumber = int(commands[1])
                except:
                    handNumber = 0
                response = self.blackjackStand(str(channel),"#"+str(ctx.message.author.id),handNumber)

            if response.startswith("accept"):
                await ctx.message.add_reaction("👍")
                #try:
                if response[6] == "T":
                    gameID = self.bot.database["blackjack games"].find_one({"_id":str(channel)})["gameID"]
                    logThis("Stand calling self.blackjackLoop()",str(channel))
                    await self.blackjackLoop(ctx.message.channel,int(response[7:])+1,gameID)
                #except:
                #    logThis("Something fucked up (error code 1320)",str(channel))
            else:
                await ctx.send(response)

        # Doubling bet
        elif content.startswith("double"):
            commands = content.split(" ")
            try:
                handNumber = int(commands[1])
            except:
                handNumber = 0
            response, roundDone = self.blackjackDouble(str(channel),"#"+str(ctx.message.author.id),handNumber)

            await ctx.send(response)

            try:
                if roundDone[0] == "T":
                    gameID = self.bot.database["blackjack games"].find_one({"_id":str(channel)})["gameID"]
                    logThis("Double calling self.blackjackLoop()",str(channel))
                    await self.blackjackLoop(ctx.message.channel,int(roundDone[1:])+1,gameID)
            except:
                logThis("Something fucked up (error code 1320)",str(channel))

        # Splitting hand
        elif content.startswith("split"):
            commands = content.split(" ")
            try:
                handNumber = int(commands[1])
            except:
                handNumber = 0
            response, roundDone = self.blackjackSplit(str(channel),"#"+str(ctx.message.author.id),handNumber)

            await ctx.send(response)

            try:
                if roundDone[0] == "T":
                    gameID = self.bot.database["blackjack games"].find_one({"_id":str(channel)})["gameID"]
                    logThis("Split calling self.blackjackLoop()",str(channel))
                    await self.blackjackLoop(ctx.message.channel,int(roundDone[1:])+1,gameID)
            except:
                logThis("Something fucked up (error code 1320)")

        # Returning current hi-lo value
        elif content.startswith("hilo"):
            data = self.bot.database["hilo"].find_one({"_id":str(channel)})
            if data != None:
                hilo = str(data["hilo"])
            else:
                hilo = "0"
            await ctx.send(hilo)

        # Shuffles the blackjack deck
        elif content.startswith("shuffle"):
            self.blackjackShuffle(blackjackDecks,str(channel))
            logThis("Shuffling the blackjack deck...",str(channel))
            await ctx.send("Shuffling the deck...")


        # Tells you the amount of cards left
        elif content.startswith("cards"):
            cardsLeft = 0
            cards = self.bot.database["blackjack cards"].find_one({"_id":str(channel)})
            if cards != None:
                cardsLeft = len(cards["cards"])

            decksLeft = round(cardsLeft/52,1)
            await ctx.send(str(cardsLeft)+" cards, "+str(decksLeft)+" decks")

        else:
            logThis("Not a command (error code 1301)")
            await ctx.send("I didn't quite understand that (error code 1301)")

