import json
import random
import copy
import math

from . import hexDraw
from funcs import logThis, getName, getID

# This is totally copied from the four in a row game. Just modified

AIScoresHex = {
    "lol, dunno": 3,
    "enemy win": -10000,
    "win": 1000,
    "avoid losing": 100
}

boardWidth = 11


# Parses command
def parseHex(command, channel, user):
    commands = command.split()
    if command == "" or command == " ":
        return "I didn't get that. Use \"!hex start [opponent]\" to start a game.", False, False, False, False
    
    elif commands[0] == "start":
        # Starting a game
        if len(commands) == 1: # if the commands is "!hex start", the opponent is Gwendolyn at difficulty 2
            commands.append("2")
        logThis("Starting a hex game with hexStart(). "+str(user)+" challenged "+commands[1])
        return hexStart(channel,user,commands[1]) # commands[1] is the opponent
    
    # Stopping the game
    elif commands[0] == "stop":
        with open("resources/games/hexGames.json", "r") as f:
            data = json.load(f)

        if user in data[channel]["players"]:
            return "Ending game.", False, False, True, False
        else:
            return "You can't end a game where you're not a player.", False, False, False, False
    
    # Placing a piece
    elif commands[0] == "place":
        try:
            return placeHex(channel,int(commands[1]),commands[2])
        except:
            return "I didn't get that. To place a piece use \"!hex place [player number] [position]\". A valid position is e.g. \"e2\".", False, False, False, False
    else:
        return "I didn't get that. Use \"!hex start [opponent]\" to start a game or \"!hex stop\" to stop a current game.", False, False, False, False


# Starts the game
def hexStart(channel, user, opponent):
    with open("resources/games/hexGames.json", "r") as f:
        data = json.load(f)
    
    if channel not in data:
        if opponent in ["1","2","3","4","5"]:
            difficulty = int(opponent)
            diffText = " with difficulty "+opponent
            opponent = "Gwendolyn"
        elif opponent.lower() == "gwendolyn":
            difficulty = 2
            diffText = " with difficulty 2"
            opponent = "Gwendolyn"
        else:
            try:
                int(opponent)
                return "That difficulty doesn't exist", False, False, False, False
            except:
                opponent = getID(opponent)
                if opponent == user:
                    return "You can't play against yourself", False, False, False, False
                elif opponent == None:
                    return "I can't find that user", False, False, False, False
                else:
                    # Opponent is another player
                    difficulty = 5
                    diffText = ""
                    
        # board is 11x11
        board = [ [ 0 for i in range(boardWidth) ] for j in range(boardWidth) ]
        players = [user,opponent]
        random.shuffle(players) # random starting player
        winningPieces = [[""],[""],[""]] # etc.

        data[channel] = {"board": board,"winner":0,
            "players":players, "winningPieces":winningPieces,"turn":0,"difficulty":difficulty}

        with open("resources/games/hexGames.json", "w") as f:
            json.dump(data,f,indent=4)
        
        # draw the board
        #fourInARowDraw.drawImage(channel)
        # hexDraw() # something something

        gwendoTurn = False

        if players[0] == "Gwendolyn":
            # in case she has the first move
            gwendoTurn = True

        return "Started game against "+getName(opponent)+ diffText+". It's "+getName(players[0])+"'s turn", True, False, False, gwendoTurn
    else:
        return "There's already a hex game going on in this channel", False, False, False, False

# Places a piece at the given location and checks things afterwards
def placeHex(channel : str,player : int,position : str):
    with open("resources/games/hexGames.json", "r") as f:
        data = json.load(f)
    
    if channel in data:
        board = data[channel]["board"]

        # Places on board
        board = placeOnHexBoard(board,player,position)
        
        
        if board != None:
            # If the move is valid:
            data[channel]["board"] = board
            turn = (data[channel]["turn"]+1)%2
            data[channel]["turn"] = turn

            with open("resources/games/hexGames.json", "w") as f:
                json.dump(data,f,indent=4)

            """
            # Checking for a win
            logThis("Checking for win")
            won, winningPieces = isHexWon(data[channel]["board"])

            if won != 0:
                gameWon = True
                data[channel]["winner"] = won
                data[channel]["winningPieces"] = winningPieces
                

                message = data[channel]["players"][won-1]+" won!"
                if data[channel]["players"][won-1] != "Gwendolyn":
                    winAmount = data[channel]["difficulty"]^2+5
                    message += " Adding "+str(winAmount)+" GwendoBucks to their account."
            else:"""
            gameWon = False
            message = data[channel]["players"][player-1]+" placed at "+position+". It's now "+data[channel]["players"][turn]+"'s turn."
            
            with open("resources/games/hexGames.json", "w") as f:
                json.dump(data,f,indent=4)
            
            # Is it Gwendolyn's turn?
            gwendoTurn = False
            if data[channel]["players"][turn] == "Gwendolyn":
                logThis("It's Gwendolyn's turn")
                gwendoTurn = True
            
            # draw the board
            #fourInARowDraw.drawImage(channel)
            # hexDraw() # something something
            return message, True, True, gameWon, gwendoTurn
        else:
            # Invalid move
            return "That move is invalid. Place only on empty spaces.", True, True, False, False
    else:
        return "There's no game in this channel", False, False, False, False


# Returns a board where the placement has occured
def placeOnHexBoard(board,player,position):
    # Translates the position
    position = position.lower()
    try:
        column = ord(position[0])-97   # ord() translates from letter to number
        row = int(position[1])
        if column not in range(boardWidth) or row not in range(boardWidth):
            logThis("Position out of bounds (error code 1533)")
            return "Error. That position is out of bounds."
    except:
        logThis("Invalid position (error code 1531)")
        return "Error. The position should be a letter followed by a number, e.g. \"e2\"."
    
    # Place at the position
    if board[row][column] == 0:
        board[row][column] = player
        return board
    else:
        logThis("Cannot place on existing piece (error code 1532)")
        return "Error. You must place on an empty space."

# Checks if someone has won the game and returns the winner
def isHexWon(board):
    won = 0
    winDirection = ""
    winCoordinates = [0,0]

    for row in range(len(board)):
        for place in range(len(board[row])):
            if won == 0:
                piecePlayer = board[row][place]
                if piecePlayer != 0:
                    # Checks horizontal
                    if place <= boardWidth-4:
                        pieces = [board[row][place+1],board[row][place+2],board[row][place+3]]
                    else:
                        pieces = [0]

                    if all(x == piecePlayer for x in pieces):
                        won = piecePlayer
                        winDirection = "h"
                        winCoordinates = [row,place]

                    # Checks vertical
                    if row <= boardWidth-4:
                        pieces = [board[row+1][place],board[row+2][place],board[row+3][place]]
                    else:
                        pieces = [0]

                    if all(x == piecePlayer for x in pieces):
                        won = piecePlayer
                        winDirection = "v"
                        winCoordinates = [row,place]

                    # Checks right diagonal
                    if row <= boardWidth-4 and place <= boardWidth-4:
                        pieces = [board[row+1][place+1],board[row+2][place+2],board[row+3][place+3]]
                    else:
                        pieces = [0]

                    if all(x == piecePlayer for x in pieces):
                        won = piecePlayer
                        winDirection = "r"
                        winCoordinates = [row,place]

                    # Checks left diagonal
                    if row <= boardWidth-4 and place >= 3:
                        pieces = [board[row+1][place-1],board[row+2][place-2],board[row+3][place-3]]
                    else:
                        pieces = [0]

                    if all(x == piecePlayer for x in pieces):
                        won = piecePlayer
                        winDirection = "l"
                        winCoordinates = [row,place]


    return won, winningPieces

# Plays as the AI
def hexAI(channel):
    logThis("Figuring out best move")
    with open("resources/games/hexGames.json", "r") as f:
        data = json.load(f)
    
    board = data[channel]["board"]
    player = data[channel]["players"].index("Gwendolyn")+1
    difficulty = data[channel]["difficulty"]

    scores = [-math.inf,-math.inf,-math.inf,-math.inf,-math.inf,-math.inf,-math.inf]
    for column in range(0,boardWidth):
        testBoard = copy.deepcopy(board)
        testBoard = placeOnHexBoard(testBoard,player,column)
        if testBoard != None:
            scores[column] = minimaxHex(testBoard,difficulty,player%2+1,player,-math.inf,math.inf,False)
        logThis("Best score for column "+str(column)+" is "+str(scores[column]))

    possibleScores = scores.copy()

    while (min(possibleScores) <= (max(possibleScores) - max(possibleScores)/10)) and len(possibleScores) != 1:
        possibleScores.remove(min(possibleScores))

    highest_score = random.choice(possibleScores)

    indices = [i for i, x in enumerate(scores) if x == highest_score]
    placement = random.choice(indices)
    return placeHex(channel,player,placement)

# Calculates points for a board
def AICalcHexPoints(board,player):
    score = 0
    otherPlayer = player%2+1

    # Adds points for middle placement
    for row in range(len(board)):
        if board[row][3] == player:
            score += AIScoresHex["middle"]

    # Checks horizontal
    for row in range(boardWidth):
        rowArray = [int(i) for i in list(board[row])]
        for place in range(boardWidth-3):
            window = rowArray[place:place+4]
            score += evaluateWindow(window,player,otherPlayer)
    
    # Checks Vertical
    for column in range(boardWidth):
        columnArray = [int(i[column]) for i in list(board)]
        for place in range(boardWidth-3):
            window = columnArray[place:place+4]
            score += evaluateWindow(window,player,otherPlayer)

    # Checks right diagonal
    for row in range(boardWidth-3):
        for place in range(boardWidth-3):
            window = [board[row][place],board[row+1][place+1],board[row+2][place+2],board[row+3][place+3]]
            score += evaluateWindow(window,player,otherPlayer)

    # Checks left diagonal
    for row in range(boardWidth-3):
        for place in range(3,boardWidth):
            window = [board[row][place],board[row+1][place-1],board[row+2][place-2],board[row+3][place-3]]
            score += evaluateWindow(window,player,otherPlayer)

    
    ## Checks if anyone has won
    #won = isHexWon(board)[0]

    ## Add points if AI wins
    #if won == player:
    #    score += AIScoresHex["win"]

    return score


#def evaluateWindow(window,player,otherPlayer):
#    if window.count(player) == 4:
#        return AIScoresHex["win"]
#    elif window.count(player) == 3 and window.count(0) == 1:
#        return AIScoresHex["three in a row"]
#    elif window.count(player) == 2 and window.count(0) == 2:
#        return AIScoresHex["two in a row"]
#    elif window.count(otherPlayer) == 4:
#        return AIScoresHex["enemy win"]
#    else:
#        return 0

def minimaxHex(board, depth, player , originalPlayer, alpha, beta, maximizingPlayer):
    terminal = ((isHexWon(board)[0] != 0) or (0 not in board[0]))
    # The depth is how many moves ahead the computer checks. This value is the difficulty. 
    if depth == 0 or terminal:
        points = AICalcHexPoints(board,originalPlayer)
        return points
    if maximizingPlayer:
        value = -math.inf
        for column in range(0,boardWidth):
            testBoard = copy.deepcopy(board)
            testBoard = placeOnHexBoard(testBoard,player,column)
            if testBoard != None:
                evaluation = minimaxHex(testBoard,depth-1,player%2+1,originalPlayer,alpha,beta,False)
                if evaluation < -9000: evaluation += AIScoresHex["avoid losing"]
                value = max(value,evaluation)
                alpha = max(alpha,evaluation)
                if beta <= alpha:
                    break
        return value
    else:
        value = math.inf
        for column in range(0,boardWidth):
            testBoard = copy.deepcopy(board)
            testBoard = placeOnHexBoard(testBoard,player,column)
            if testBoard != None:
                evaluation = minimaxHex(testBoard,depth-1,player%2+1,originalPlayer,alpha,beta,True)
                if evaluation < -9000: evaluation += AIScoresHex["avoid losing"]
                value = min(value,evaluation)
                beta = min(beta,evaluation)
                if beta <= alpha:
                    break
        return value

