import struct, string

class OthelloBoard:

    def __init__(self):
        self.board = [[' ']*8 for i in range(8)]
        self.size = 8
        self.board[4][4] = 'W'
        self.board[3][4] = 'B'
        self.board[3][3] = 'W'
        self.board[4][3] = 'B'
        # a list of unit vectors (row, col)
        self.directions = [ (-1,-1), (-1,0), (-1,1), (0,-1),(0,1),(1,-1),(1,0),(1,1)]
        
#prints the board
    def PrintBoard(self):

        # Print column numbers
        print("  ",end="")
        for i in range(self.size):
            print(i+1,end=" ")
        print()

        # Build horizontal separator
        linestr = " " + ("+-" * self.size) + "+"

        # Print board
        for i in range(self.size):
            print(linestr)                       # Separator
            print(i+1,end="|")                   # Row number
            for j in range(self.size):
                print(self.board[i][j],end="|")  # board[i][j] and pipe separator 
            print()                              # End line
        print(linestr)

    def board_full(self):
        for i in range(self.size):
            for j in range(self.size):
                if self.get_square(i,j)==" ":
                    return False
        return True
    
#determines the score of the board by adding +1 for every tile owned by player, and -1 for every tile owned by opp
    def score(self, player, opp):
        score = 0
        for i in range(self.size):
            for j in range(self.size):
                if(self.get_square(i,j)==player):
                    score +=1
                elif(self.get_square(i,j)==opp):
                    score -= 1
        return score

#returns true if the square was played, false if the move is not allowed
    def play_square(self, row, col, player, opp):
        if(self.get_square(row,col)!=" "):
            return False
        
        
        if(player == opp):
            print("player and opponent cannot be the same")
            return False
        legal = False
        #for each direction, check to see if the move is legal by seeing if the adjacent square
        #in that direction is occuipied by the opponent. If it isnt check the next direction.
        #if it is, check to see if one of the players pieces is on the board beyond the oppponents piece,
        #if the chain of opponents pieces is flanked on both ends by the players pieces, flip
        #the opponents pieces 
        for Dir in self.directions:
            #look across the length of the board to see if the neighboring squares are empty,
            #held by the player, or held by the opponent
            for i in range(self.size):
                if  ((( row + i*Dir[0])<self.size)  and (( row + i*Dir[0])>=0 ) and (( col + i*Dir[1])>=0 ) and (( col + i*Dir[1])<self.size )):
                    #does the adjacent square in direction dir belong to the opponent?
                    if self.get_square(row+ i*Dir[0], col + i*Dir[1])!= opp and i==1 : # no
                        #no pieces will be flipped in this direction, so skip it
                        break
                    #yes the adjacent piece belonged to the opponent, now lets see if there are a chain
                    #of opponent pieces
                    if self.get_square(row+ i*Dir[0], col + i*Dir[1])==" " and i!=0 :
                        break

                    #with one of player's pieces at the other end
                    if self.get_square(row+ i*Dir[0], col + i*Dir[1])==player and i!=0 and i!=1 :
                        #set a flag so we know that the move was legal
                        legal = True
                        self.flip_tiles(row, col, Dir, i, player)
                        break
                    
                        
        return legal


#sets all tiles along a given direction (Dir) from a given starting point (col and row) for a given distance
# (dist) to be a given value ( player )
    def flip_tiles(self, row, col, Dir, dist, player):
        for i in range(dist):
            self.board[row+ i*Dir[0]][col + i*Dir[1]] = player
        return True
    
#returns the value of a square on the board
    def get_square(self, row, col):
        return self.board[row][col]

#checks all board positions to see if there is a legal move
    def has_move(self, player, opp):
        for i in range(self.size):
            for j in range(self.size):
                if self.islegal(i,j,player,opp):
                    return True
        return False

#checks every direction fromt the position which is input via "col" and "row", to see if there is an opponent piece
#in one of the directions. If the input position is adjacent to an opponents piece, this function looks to see if there is a
#a chain of opponent pieces in that direction, which ends with one of the players pieces.    
    def islegal(self, row, col, player, opp):
        if(self.get_square(row,col)!=" "):
            return False
        for Dir in self.directions:
            for i in range(self.size):
                if  ((( row + i*Dir[0])<self.size)  and (( row + i*Dir[0])>=0 ) and (( col + i*Dir[1])>=0 ) and (( col + i*Dir[1])<self.size )):
                    #does the adjacent square in direction dir belong to the opponent?
                    if self.get_square(row+ i*Dir[0],col + i*Dir[1])!= opp and i==1 : # no
                        #no pieces will be flipped in this direction, so skip it
                        break
                    #yes the adjacent piece belonged to the opponent, now lets see if there are a chain
                    #of opponent pieces
                    if self.get_square(row+ i*Dir[0], col + i*Dir[1])==" " and i!=0 :
                        break

                    #with one of player's pieces at the other end
                    if self.get_square(row+ i*Dir[0], col + i*Dir[1])==player and i!=0 and i!=1 :
                        #set a flag so we know that the move was legal
                        return True
        return False

#returns true if no square in the board contains "_", false otherwise
    def full_board(self):
        for i in range(self.size):
            for j in range(self.size):
                if(self.board[i][j]==' '):
                    return False

        return True
    
#Checks to see if the given player controls the entire board
    def all_pieces(self, player):
        for i in range(self.size):
            for j in range(self.size):
                if(self.get_square(i,j) != player and self.get_square(i,j) != ' '):
                    return False
        return True
                   
#The cpu will search the game board for a legal move, and play the first one it finds
def make_simple_cpu_move(board, cpuval, oppval):
    for i in range(board.size):
        for j in range(board.size):
            if(board.islegal(i,j,cpuval, oppval)):
                board.play_square(i,j,cpuval, oppval)
                print("CPU has played row: " +str(i+1)+"  col: "+str(j+1))
                return True
    return False


def main():
    b = OthelloBoard()
    b.PrintBoard()

    Human = 'B'
    CPU = 'W'
    player = Human
    opp = CPU
   
    #alternate between human's turn and CPU turn. if theres is no available move for one of the players, then
    #it becomes their opponents turn again.
    #if the board is full, the winner is announced
    while( b.full_board()==False ):
        if player==Human :
            if b.all_pieces(player):
                break
            if(b.has_move(player, opp)):
                while True:
                    print("Player: " + player)
                    
                    try:
                        row = int(input("Pick a row (1-8): "))
                        if row < 1 or row > b.size:
                            raise ValueError("Board requires input between 1 and %d, inclusive." % b.size)
                        
                        col = int(input("Pick a col (1-8): "))
                        if col < 1 or col > b.size:
                            raise ValueError("Board requires input between 1 and %d, inclusive." % b.size)

                    # ValueError occurs when user inputs non-integer values
                    #   or integers outside of the range of the board
                    except ValueError:
                        print("Illegal move.")
                        continue # Loop back to while True loop

                    # Check validity of move. If valid, change board
                    #   and exit while True loop
                    if(b.play_square(row-1,col-1,player,opp)):
                        b.PrintBoard()
                        break

                    print("Illegal move.")
            else:
                print("No move available.")
            player = CPU
            opp = Human
            continue


        elif player==CPU :
            if b.all_pieces(player):
                break
            if(b.has_move(player, opp)):
                print("CPU has available moves.")
                make_simple_cpu_move(b, CPU, Human)
                b.PrintBoard()
                player = Human
                opp = CPU
            else:
                print("CPU has no available moves.")
                player = Human
                opp = CPU
                continue


            
    if( b.score(Human, CPU) > 0):
        print("The winner is: "+ Human)
    elif(b.score(Human, CPU) == 0):
        print("The game is a draw")
    else:
        print("The winner is: " + CPU)
main()