#another tic tac toe game
import random
from random import randint
#gameboard interface

gameboard = [[" "] * 3, [" "] * 3, [" "] * 3] # 2d Array
input_var1 = [["a1", "b1", "c1"], ["a2", "b2", "c2"], ["a3", "b3", "c3"]]
input_var2 = [["1a", "1b", "1c"], ["2a", "2b", "2c"], ["3a", "3b", "3c"]]
available_moves = ["a1", "b1", "c1", "a2", "b2", "c2", "a3", "b3", "c3"]
rows = 3
columns = 3
player_symbols = ["_", "X", "O"]
current_player = 1

def end_game():

    global gameboard
    global available_moves
    global current_player

    replay = input("Do you want to play again? Y/N: ")

    if replay == "Y" or replay == "y":
        gameboard = [[" "] * 3, [" "] * 3, [" "] * 3] # 2d Array
        available_moves = ["a1", "b1", "c1", "a2", "b2", "c2", "a3", "b3", "c3"]
        current_player = 1
        main_game_loop()


    else:
        quit()

def draw_gameboard(): #this is our game output
    print("    A    B    C")
    for i in range(len(gameboard)):
        print(i+1, (gameboard[i]))

def get_player_input():
    print("It's your turn, proper input example is 'a3', or 'b1'. Enter 'x' to quit")
    pos = input("Enter position you want to take:")
    if pos == "x":
        quit()
    return pos

def get_ai_input():

    column_check = []

#horizontal logic
    for y in range(len(gameboard[0])):
        for i in range(len(gameboard[y])):
            if gameboard[y].count(gameboard[y][i]) == len(gameboard[y])-1 and gameboard[y][i] == "O":
                for x in range(len(gameboard[y])):
                    if input_var1[y][x] in available_moves:
                        pos = input_var1[y][x]
                        return pos

    for y in range(len(gameboard[0])):
        for i in range(len(gameboard[y])):
            if gameboard[y].count(gameboard[y][i]) == len(gameboard[y])-1 and gameboard[y][i] == "X":
                for x in range(len(gameboard[y])):
                    if input_var1[y][x] in available_moves:
                        pos = input_var1[y][x]
                        return pos


#vertical logic
    for i in range(len(gameboard)):
        for row in gameboard:
            column_check.append(row[i])
        for j in range(len(column_check)):
            if column_check.count(column_check[j]) == len(column_check)-1 and column_check[j] == "O":
                for row in input_var1:
                    if input_var1[input_var1.index(row)][i] in available_moves:
                        pos = input_var1[input_var1.index(row)][i]
                        return pos
        #print(column_check)
        column_check.clear()

    for i in range(len(gameboard)):
        for row in gameboard:
            column_check.append(row[i])
        for j in range(len(column_check)):
            if column_check.count(column_check[j]) == len(column_check)-1 and column_check[j] == "X":
                for row in input_var1:
                    if input_var1[input_var1.index(row)][i] in available_moves:
                        pos = input_var1[input_var1.index(row)][i]
                        return pos
        #print(column_check)
        column_check.clear()

#diagonal right logic

    for counter, row in enumerate(gameboard):
        column_check.append(row[counter])
    for i in range(len(gameboard)):
        if column_check.count(column_check[i]) == len(column_check)-1 and column_check[i] != " ":
            for counter, row in enumerate(input_var1):
                if input_var1[input_var1.index(row)][counter] in available_moves:
                    pos = input_var1[input_var1.index(row)][counter]
                    return pos

    column_check.clear()

#diagonal left logic

    for counter, row in enumerate(gameboard):
        column_check.append(row[-counter-1])
    for i in range(len(gameboard)):
        if column_check.count(column_check[i]) == len(column_check)-1 and column_check[i] != " ":
            for counter, row in enumerate(input_var1):
                if input_var1[input_var1.index(row)][-counter-1] in available_moves:
                    pos = input_var1[input_var1.index(row)][-counter-1]
                    return pos

    if "b2" in available_moves:
        pos = "b2"
        return pos

    else:
        pos = available_moves[randint(0, (len(available_moves))-1)]
        return pos

def update_game(player_number):
    global gameboard
    global input_var1
    global current_player

    if player_number == 1:
        pos = get_player_input()
    else:
        pos = get_ai_input()

    if pos in available_moves:
        available_moves.remove(pos)

        for x in range(len(input_var1)):
            for y in range(len(input_var1[x])):
                if input_var1[x][y] == pos or input_var2[x][y] == pos:
                    gameboard[x][y] = player_symbols[player_number]
                    print(" ")
                    print("Player", player_number, "move: ")
    else:
        print("this position is invalid or already taken")
        update_game(player_number)

def check_for_winners():
    global current_player
    column_check = []
#horizontal
    for x in range(len(gameboard[0])):
        if gameboard[x].count(gameboard[x][0]) == len(gameboard[x]) and gameboard[x][0] != " ":
            #there is horizontal winner
            print("We have a winner - horizontal", "Player ", current_player, " has won!")
            draw_gameboard()
            end_game()
#vertical
    for i in range(len(gameboard)):
        for row in gameboard:
            column_check.append(row[i])
        if column_check.count(column_check[0]) == len(column_check) and column_check[0] != " ":
            #there is vertical winner
            print("We have a winner - vertical", "Player ", current_player, " has won!")
            draw_gameboard()
            end_game()
        else:
            column_check.clear()
#diagonal right
    for counter, row in enumerate(gameboard):
        column_check.append(row[counter])
    if column_check.count(column_check[0]) == len(column_check) and column_check[0] != " ":
            #there is diagonal winner
            print("We have a winner - diagonal", "Player ", current_player, " has won!")
            draw_gameboard()
            end_game()
    else:
        column_check.clear()

#diagonal left
    for counter, row in enumerate(gameboard):
        column_check.append(row[-counter-1])
    if column_check.count(column_check[0]) == len(column_check) and column_check[0] != " ":
            #there is diagonal winner
            print("We have a winner - diagonal", "Player ", current_player, " has won!")
            draw_gameboard()
            end_game()
    else:
        column_check.clear()

#check for TIE
    if len(available_moves) == 0:
        print("It's a TIE!")
        end_game()

    if current_player == 1:
        current_player = 2
    else:
        current_player = 1

def main_game_loop():
    game_ended = False
    while game_ended == False:

        draw_gameboard()
        update_game(current_player)
        check_for_winners()

    else:
        quit()

main_game_loop()