# Domácí úkol 05
# IB113/03
# autor: JMÉNO PŘIJMENÍ


def print_board(board):
    """
    4 body
    vytiskni hraci pole dle vzoru nize
    :param board: 2D list
    """
    pass


def end_of_game(board):
    """
    6 body
    True pokud uz na hracim planu nezbyva zadne volne pole
    :param board: 2D list
    :return: bool
    """
    pass


def write_symbol(x, y, board, symbol):
    """
    4 body
    Zapíše znak 'symbol' na souradnice herniho planu x, y
    :param x: cislo radku
    :param y: cislo sloupce
    :param board: hraci plan
    :param symbol: symbol 'x' nebo 'o'
    :return: None
    """
    pass


def is_empty(x, y, board):
    """
    6 body
    Zkontroluje, zda dane pole je prazdne
    (netahlo se na nej, neni blokovane)
    :param x: cislo radku
    :param y: cislo sloupce
    :param board: hraci pole
    :return: True, pokud je mozne na pole hrat
    """
    pass


def human_player(board, symbol):
    """
    funkce umoznuje hrat BLOCK GAME lidskemu hraci
    Nejprve vypise hraci pole a nabidne hraci zadat souradnice jeho tahu.
    Kazdy tah zkontroluje zda je validni. Funkce nesmi spadnout s chybou,
    pokud hrac chce hrat na pole, ktere je jiz blokovane, ktere je mimo
    hraci plan nebo zada misto souradnic nahodny sled znaku. Pri nevalidnim
    vstupu funkce popise problem a necha hrace hrat znovu.

    :param board: instance hraciho planu pred tahem
    :param symbol: identifikacni znak hrace
    :return: None
    """
    pass


# UKOL 2
def my_strategy(board, symbol):
    """
    funkce implementující strategii
    implementujte a vytvořte další obdobné funkce
    :param board: instance hraciho planu pred tahem
    :param symbol: identifikacni znak hrace
    :return: None
    """
    pass


def block_game(width,
               height,
               player1=human_player,
               player2=human_player):
    """
    funkce spusti jednu instanci BLOCK GAME
    funkce prijima ruzne strategie hry, zakladni strategii je interakce
    s lidskym hracem hraci plan je instanci teto funkce, kazda strategie,
    pokud je zavolana, zmeni stav planu funkce tiskne informace o hre,
    pokud je nastaveny parametr output na True

    :param width: delka hraciho planu, od 1 do 9
    :param height: vyska hraciho planu, od 1 do 9
    :param player1: strategie prvniho hrace
    :param player2: strategie druheho hrace
    :return: pocet odehranych kol

    """

    board = [['.' for _ in range(width)]
             for _ in range(height)]

    symbols = ['x', 'o']
    players = [player2, player1]
    game_round = 0
    symbol = symbols[0]

    # cyklus hry
    # hráči se střídají, dokud není konec hry
    while not end_of_game(board):

        # rozhodnutí, jaký hraje hráč a jaký má symbol
        game_round += 1
        symbol = symbols[game_round % 2]
        player = players[game_round % 2]

        # vytištění informací o probíhajícím kole
        print()
        print('ROUND {}'.format(game_round))

        # hra hráče
        # úprava hracího plánu
        player(board, symbol)

        # tisk aktuálního stavu hracího pole
        print_board(board)

    print(f'player {symbol} won')
    print('end of the game')
    return game_round


if __name__ == '__main__':
    block_game(5, 6)