import struct, string

class OthelloBoard:

    def __init__(self):
        self.board = ([' ']*8,[' ']*8,[' ']*8,[' ']*8 ,[' ']*8 ,[' ']*8 ,[' ']*8 ,[' ']*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("  0 1 2 3 4 5 6 7")
        linestr = " "
        for j in range(self.size):
            linestr = linestr + "+-"
        linestr = linestr + "+"
        for i in range(self.size):
            strng = str(i) + "|"
            print(linestr)
            for k in range(self.size):
                strng = strng + self.board[i][k] + "|"
            print(strng)
        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, col, row, player, opp):
        if(self.get_square(col,row)!=" "):
            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(col + i*Dir[1], row+ i*Dir[0])!= 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(col + i*Dir[1], row+ i*Dir[0])==" " and i!=0 :
                        break

                    #with one of player's pieces at the other end
                    if self.get_square(col + i*Dir[1], row+ i*Dir[0])==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, col, row):
        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, col, row, player, opp):
        if(self.get_square(col,row)!=" "):
            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(col + i*Dir[1], row+ i*Dir[0])!= 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(col + i*Dir[1], row+ i*Dir[0])==" " and i!=0 :
                        break

                    #with one of player's pieces at the other end
                    if self.get_square(col + i*Dir[1], row+ i*Dir[0])==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(j)+"  col: "+str(i))
                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
            print("Player: " + player)
            if(b.has_move(player, opp)):
                while True:

                    print("Player: " + player)
                    print("pick a row (0-2)")
                    row = int(input())
                    print("pick a col (0-2)")
                    col = int(input())#
                    if(b.play_square(col,row,player,opp)):
                        b.PrintBoard()
                        break
            else:
                print("no move")
            player = CPU
            opp = Human
            continue


        elif player==CPU :
            if b.all_pieces(player):
                break
            if(b.has_move(player, opp)):
                print("CPU has move")
                make_simple_cpu_move(b, CPU, Human)
                b.PrintBoard()
                player = Human
                opp = CPU
            else:
                print("no move")
                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()