import os
import random
import time
from tkinter import *
import pandas as pd

from bin.Classess.Field import Field
from bin.Classess.Mine import Mine
from bin.Classess.Travel import Travel
from bin.Classess.Player import Player
from bin.Classess.NeuralNetwork import NeuralNetwork
import bin.Classess.Node as nd
import bin.Classess.Travel as tr
from resources.Globals import *
from bin.Classess.DecisionTree import DecisionTree

# Creating objects
player = Player()
field = Field()
travel = Travel()
decision_tree = DecisionTree()
neural_network = NeuralNetwork()

# Globals
fringe = []
explored = []
action_list = []
images_coord = []

label = None


def Arrow(direction):
    image = ""
    if direction == "north":
        image = player.arrow_north_image
    elif direction == "south":
        image = player.arrow_south_image
    elif direction == "west":
        image = player.arrow_west_image
    elif direction == "east":
        image = player.arrow_east_image

    field.small_field_canvas.itemconfig(player.image_canvas_id, image=image)


# Putting images
def Fill(bool):
    global images_coord
    if bool:
        field.PuttingSmallImages()

        travel.points_coord.append(field.small_field_canvas.coords(field.canvas_small_images[0]))
        travel.points_coord.extend(field.mines_coord)

        for i in range(0, len(travel.points_coord)):
            travel.points_map[i + 1] = travel.points_coord[i]

        print(travel.points_map)

        for i in range(0, len(field.canvas_small_images)):
            images_coord.append(field.small_field_canvas.coords(field.canvas_small_images[i]))

        nd.init_data(images_coord, field.cell_expense)

    DrawingLargeImage()


def DrawingLargeImage():
    large_img_name = field.large_image_array[player.current_array_x][player.current_array_y]  # ToDo change positions?

    # print(
    #     f'large image path[{player.current_array_x}][{player.current_array_y}]: {field.large_image_array_filepath[player.current_array_x][player.current_array_y]}')

    field.PuttingLargeImage(large_img_name)


def NextDirection(action):
    # Define next direction
    current_direction = player.direction
    t = -1
    for i in range(4):
        if player.directions[i] == current_direction:
            t = i
            break

    # Write next direction to Player
    if action == "Right":
        player.direction = player.directions[(t + 1) % 4]
    elif action == "Left":
        player.direction = player.directions[(t - 1) % 4]

    return player.direction


def MovingForward():
    if player.direction == "east" and field.small_field_canvas.coords(player.image_canvas_id)[
        0] + player.step < FRAME_WIDTH:
        field.small_field_canvas.move(player.image_canvas_id, player.step, 0)
    elif player.direction == "west" and field.small_field_canvas.coords(player.image_canvas_id)[0] > player.x_start:
        field.small_field_canvas.move(player.image_canvas_id, -player.step, 0)
    elif player.direction == "north" and field.small_field_canvas.coords(player.image_canvas_id)[1] > player.y_start:
        field.small_field_canvas.move(player.image_canvas_id, 0, -player.step)
    elif player.direction == "south" and field.small_field_canvas.coords(player.image_canvas_id)[
        1] + player.step < FRAME_HEIGHT:
        field.small_field_canvas.move(player.image_canvas_id, 0, player.step)


def Moving(action):
    # Moving
    if action == "Right":
        # player.MovingRight()
        field.Moving()
        Fill(False)
        next_direction = NextDirection(action)
        Arrow(next_direction)
    elif action == "Left":
        # player.MovingLeft()
        field.Moving()
        Fill(False)
        next_direction = NextDirection(action)
        Arrow(next_direction)
    elif action == "Up":
        player.Moving()
        field.Moving()
        Fill(False)
        MovingForward()
        Arrow(player.direction)


def ImagesInArray(images_array, array, paths_array, switch):
    # Filling array from directory
    row = column = 0

    for i in range(len(images_array)):
        is_done = False
        while not is_done:
            if array[row][column] == 0:
                array[row][column] = images_array[i]
                if switch:
                    field.large_image_array_filepath[row][column] = paths_array[i]
                is_done = True
            else:
                column += 1
                if column == 10:
                    column = 0
                    row += 1
                if row == 10:
                    break

        column += 1
        if column == 10:
            column = 0
            row += 1
        if row == 10:
            break

    # for el in images_array:
    #     is_done = False
    #     while not is_done:
    #         if array[row][column] == 0:
    #             array[row][column] = el
    #             is_done = True
    #         else:
    #             column += 1
    #             if column == 10:
    #                 column = 0
    #                 row += 1
    #             if row == 10:
    #                 break
    #
    #     column += 1
    #     if column == 10:
    #         column = 0
    #         row += 1
    #     if row == 10:
    #         break


def CellDesignation(array, color):
    for element in array:
        if element[0] == 0:
            element[0] = player.current_x
            element[1] = player.current_y
            element[2] = color
            break


def Action(action):
    if action in ["Right", "Left", "Up", "space"]:
        Moving(action)
    # elif action in ["1", "2"]:
    #     if action == "1":
    #         CellDesignation(field.state_of_cell_array, "red")
    #     else:
    #         CellDesignation(field.state_of_cell_array, "green")


# Modified by Artem to search in the status area
def create_action_list(states, index):
    global fringe
    global action_list

    if index == 0:
        action_list.reverse()
        return True
    action_list.append(fringe[index].action)
    state_parent = [fringe[index].parent[0], fringe[index].parent[1]]
    create_action_list(states, states.index(state_parent))


def MakeDecision():
    if player.current_array_x != 0 or player.current_array_y != 0:
        mine = field.state_of_cell_array[player.current_array_x][player.current_array_y]
        # print(field.state_of_cell_array)
        # print(mine)
        attributes_dict = {'known': [mine.known], 'power': [mine.power], 'new': [mine.new], 'location': [mine.location],
                           'stable': [mine.stable], 'chain_reaction': [mine.chain_reaction]}

        attributes = f'{mine.known}; {mine.power}; {mine.new}; {mine.location}; {mine.stable}; {mine.chain_reaction}'

        global label_text
        label_text += attributes + '\n'

        global label
        label.config(text=label_text)
        field.win.update()

        data_frame = pd.DataFrame.from_dict(attributes_dict)
        predict = decision_tree.classifier.predict(data_frame)

        return predict


def MarkMine(prediction):
    if prediction == 0:
        DrawFlag(field.flag_green_img)
    if prediction == 1:
        DrawFlag(field.flag_yellow_img)
    if prediction == 2:
        DrawFlag(field.flag_red_img)
    if prediction == 3:
        DrawFlag(field.flag_bleu_img)

    field.win.update()


def ChangeChainReactionParameter(prediction, source_x, source_y, x, y):
    if prediction == 0:
        # print(f"x: {source_x}; y: {source_y}")
        # print(f'state of cell: {field.state_of_cell_array[source_x][source_y]}')
        # print(f'img path: {field.large_image_array_filepath}')
        field.state_of_cell_array[source_x][source_y].chain_reaction = 1
        field.state_of_cell_array[x][y] = "House"


def CheckIfItIsHouse(x, y):
    prediction = NeuralNetwork.Prediction(neural_network, x, y, field)

    house = prediction[0][0]
    other = prediction[0][1]

    if house > other:
        prediction = 0
    else:
        prediction = 1

    print(f'Prediction: {prediction}')

    return prediction


def CheckForHouses():
    if player.current_array_x > 0 and field.state_of_cell_array[player.current_array_x - 1][
        player.current_array_y] == "None":
        prediction = CheckIfItIsHouse(player.current_array_x - 1, player.current_array_y)
        ChangeChainReactionParameter(prediction, player.current_array_x, player.current_array_y,
                                     player.current_array_x - 1, player.current_array_y)
    if player.current_array_x < 9 and field.state_of_cell_array[player.current_array_x + 1][
        player.current_array_y] == "None":
        prediction = CheckIfItIsHouse(player.current_array_x + 1, player.current_array_y)
        ChangeChainReactionParameter(prediction, player.current_array_x, player.current_array_y,
                                     player.current_array_x + 1, player.current_array_y)
    if player.current_array_y > 0 and field.state_of_cell_array[player.current_array_x][
        player.current_array_y - 1] == "None":
        prediction = CheckIfItIsHouse(player.current_array_x, player.current_array_y - 1)
        ChangeChainReactionParameter(prediction, player.current_array_x, player.current_array_y,
                                     player.current_array_x, player.current_array_y - 1)
    if player.current_array_y < 9 and field.state_of_cell_array[player.current_array_x][
        player.current_array_y + 1] == "None":
        prediction = CheckIfItIsHouse(player.current_array_x, player.current_array_y + 1)
        ChangeChainReactionParameter(prediction, player.current_array_x, player.current_array_y,
                                     player.current_array_x, player.current_array_y + 1)


def MouseClickEvent(track):
    global fringe
    global explored
    global action_list

    print("The best individual is: {} {}".format(track[1], track[0]))
    for point in range(0, len(track[1]) + 1):
        start_position = field.small_field_canvas.coords(player.image_canvas_id)
        if point == len(track[1]):
            end_position = travel.points_map[1]
        else:
            end_position = travel.points_map[track[1][point]]

        node = nd.Node()
        if len(fringe) == 0:
            node.state.coord = start_position
            node.state.direction = "east"
        else:
            states = []
            for k in range(0, len(fringe)):
                new_state = fringe[k].state.coord
                states.append(new_state)
            start_node = fringe[-1]

            node.state.coord = start_node.state.coord
            node.state.direction = start_node.state.direction

        fringe.clear()
        explored.clear()
        action_list.clear()
        fringe = nd.graph_search_A(fringe, explored, node.state, end_position)

        states = []
        goal_all = []
        for i in range(0, len(fringe)):
            new_state = [fringe[i].state.coord, fringe[i].state.direction]
            states.append(new_state)
            if end_position[0] == fringe[i].state.coord[0] and end_position[1] == fringe[i].state.coord[1]:
                goal_all.append(fringe[i])

        elem_min = goal_all[0]
        for i in range(1, len(goal_all)):
            if elem_min.priority > goal_all[i].priority:
                elem_min = goal_all[i]
        index = fringe.index(elem_min)
        fringe = fringe[:index + 1]

        create_action_list(states, -1)

        # Start moving
        AutoMove()

        # Condition, that not allow check if in 0, 0
        if player.current_array_x > 0 and player.current_y > 0:
            # Check if there are houses nearby
            print()
            CheckForHouses()

        # Decision by tree
        prediction = MakeDecision()
        # Draw the right flag
        MarkMine(prediction)

        time.sleep(SLEEP_AFTER_CHECK_MINE)


# Check in which locations is mine
def CheckLocation(x, y):
    # Add x + y like strings that create xy number
    temp_x = str(x)
    temp_y = str(y)
    position_str = temp_x + temp_y
    position = int(position_str)

    color_number = -1
    if field.cell_expense[position] == standard_cell_cost:
        color_number = 0
    elif field.cell_expense[position] == sand_cell_cost:
        color_number = 1
    elif field.cell_expense[position] == water_cell_cost:
        color_number = 2
    elif field.cell_expense[position] == swamp_cell_cost:
        color_number = 3

    return color_number


# Add mines on the field and to arrays
def PutMines(mines_array):
    counter = 0

    while counter < AMOUNT_OF_MINES:
        x = random.randint(0, 9)
        y = random.randint(0, 9)

        is_equal = False

        for mine in mines_array:
            if mine.array_x == x and mine.array_y == y:
                is_equal = True
        if not is_equal:
            if x == 0 and y == 0:
                continue
            else:
                known = random.randint(0, 1)
                power = random.randint(1, 10)
                new = random.randint(0, 1)
                location = CheckLocation(x, y)
                stable = random.randint(0, 1)

                mine = Mine(x, y, known, power, new, location, stable)
                mines_array.append(mine)

                # Add mine to array at the right position
                field.state_of_cell_array[x][y] = mine

                field.field_state_array[x][y] = True

                counter += 1


def MinesInArrays(mines_array, directory, imgs_array, bool_mines_coord):
    counter = 0

    temp_array = []

    if directory == "../../files/small_mines_images":
        for file in os.listdir(directory):
            if counter < AMOUNT_OF_MINES:
                image_name = file
                image_path = f"{directory}/{image_name}"
                image = PhotoImage(master=field.small_field_canvas, file=image_path)

                temp_array.append(image)

                counter += 1

        for i in range(AMOUNT_OF_MINES):
            mines_array[i].small_img = temp_array[i]

            # Add images in image array
            imgs_array[mines_array[i].array_x][mines_array[i].array_y] = temp_array[i]

    elif directory == "../../files/large_mines_images":
        for file in os.listdir(directory):
            if counter < AMOUNT_OF_MINES:
                image_name = file
                image_path = f"{directory}/{image_name}"
                image = PhotoImage(master=field.large_image_canvas, file=image_path)

                temp_array.append(image)

                counter += 1

        for i in range(AMOUNT_OF_MINES):
            mines_array[i].large_img = temp_array[i]

            # Add images in image array
            imgs_array[mines_array[i].array_x][mines_array[i].array_y] = temp_array[i]

    if bool_mines_coord:
        for i in range(len(mines_array)):
            field.mines_coord.append([mines_array[i].array_x, mines_array[i].array_y])


def DrawFlag(image):
    field.small_field_canvas.create_image(player.current_x, player.current_y, anchor=NW, image=image)


# def IsItMine():
#     visited = 0     # 0 - not mine; 1 - on this mine for the first time; 2 - already been on this mine
#
#     # Checks if the player is on the mine
#     for i in field.mines_coord:
#         if i[0] == player.current_x and i[1] == player.current_y:
#             visited = 1
#             # Checks if the player has already been on this mine
#             for y in field.visited_mines:
#                 if y[0] == player.current_x and y[1] == player.current_y:
#                     visited = 2
#         if visited == 1:
#             DrawFlag()


def AutoMove():
    for action in action_list:
        # Program wait for better illustration
        time.sleep(DELAY_TIME)
        # Move once
        Action(action)
        # Check if player on mine and if yes, draw flag
        # IsItMine()
        # Update main window
        field.win.update()


# Draws rectangles that indicate type of cells
def DrawRectangle():
    x = 4
    y = 4

    color = None
    # Chose color for rectangle
    for i in range(len(field.cell_expense)):
        if field.cell_expense[i] == standard_cell_cost:
            color = "None"
        elif field.cell_expense[i] == sand_cell_cost:
            color = "yellow"
        elif field.cell_expense[i] == water_cell_cost:
            color = "dodger blue"
        elif field.cell_expense[i] == swamp_cell_cost:
            color = "green4"
        if color != "None":
            field.small_field_canvas.create_rectangle(x, y, x + IMAGE_SIZE + 2, y + IMAGE_SIZE + 2, width=2,
                                                      outline=color)
        x += player.step
        if x + IMAGE_SIZE + 2 > field.width:
            x = 4
            y += player.step


def AddCostCellsToArray(amount, cost):
    counter = 0
    while counter < amount:
        r = random.randint(0, 99)
        if field.cell_expense[r] == 0:
            field.cell_expense[r] = cost
            counter += 1


def CostingOfCells():
    AddCostCellsToArray(amount_of_sand_cells, sand_cell_cost)
    AddCostCellsToArray(amount_of_water_cells, water_cell_cost)
    AddCostCellsToArray(amount_of_swamp_cells, swamp_cell_cost)
    AddCostCellsToArray(
        field.rows * field.columns - (amount_of_sand_cells + amount_of_water_cells + amount_of_swamp_cells),
        standard_cell_cost)

    # Draw rectangles
    DrawRectangle()


def click_button():
    btn.destroy()
    global label
    label = Label(field.win, text="Wait...\nAI conquers the world...", fg='black', font="20", bg='gray')
    label.place(x=10, y=560)
    field.win.update()
    track = tr.genetic_algorithm(travel.points_map)

    track[1].remove(1)
    label.config(text=track[1])
    field.win.update()
    MouseClickEvent(track)


# Check if there mines near and if, mark it
def CheckForMinesAndHousesNear(x, y):
    if x > 0:
        if field.state_of_cell_array[x - 1][y] != "None":
            # Mark by chain reaction current mine
            field.state_of_cell_array[x][y].chain_reaction = 1
            # Mark by chain reaction mine that near
            field.state_of_cell_array[x - 1][y].chain_reaction = 1
    if x < 9:
        if field.state_of_cell_array[x + 1][y] != "None":
            # Mark by chain reaction current mine
            field.state_of_cell_array[x][y].chain_reaction = 1
            # Mark by chain reaction mine that near
            field.state_of_cell_array[x + 1][y].chain_reaction = 1
    if y > 0:
        if field.state_of_cell_array[x][y - 1] != "None":
            # Mark by chain reaction current mine
            field.state_of_cell_array[x][y].chain_reaction = 1
            # Mark by chain reaction mine that near
            field.state_of_cell_array[x][y - 1].chain_reaction = 1
    if y < 9:
        if field.state_of_cell_array[x][y + 1] != "None":
            # Mark by chain reaction current mine
            field.state_of_cell_array[x][y].chain_reaction = 1
            # Mark by chain reaction mine that near
            field.state_of_cell_array[x][y + 1].chain_reaction = 1


def CheckForChainReaction():
    for x in range(field.columns):
        for y in range(field.rows):
            if field.state_of_cell_array[x][y] != "None":
                CheckForMinesAndHousesNear(x, y)


def LoadAndMixImages(directory_small_images, directory_large_images):
    small_images_array = []
    large_images_array = []
    large_image_array_filepath = []

    for filename in os.listdir(directory_small_images):
        image_path = f"{directory_small_images}/{filename}"
        image = PhotoImage(master=field.small_field_canvas, file=image_path)

        small_images_array.append(image)

    for filename in os.listdir(directory_large_images):
        image_path = f"{directory_large_images}/{filename}"
        image = PhotoImage(master=field.large_image_canvas, file=image_path)

        large_images_array.append(image)
        large_image_array_filepath.append(f'{directory_large_images}/{filename}')

    zip_array = list(zip(small_images_array, large_images_array, large_image_array_filepath))

    random.shuffle(zip_array)

    small_images_array, large_images_array, large_image_array_filepath = zip(*zip_array)

    return small_images_array, large_images_array, large_image_array_filepath


def HousesImagesInArray(images_array, array_for_images, array_of_paths, is_large_images):
    i = 0
    while i < AMOUNT_OF_HOUSES:
        x = random.randint(0, 9)
        y = random.randint(0, 9)

        if array_for_images[x][y] == 0:
            array_for_images[x][y] = images_array[i]
            if is_large_images:
                field.large_image_array_filepath[x][y] = array_of_paths[i]
            i += 1


def funct(small_images_of_houses_array, large_images_of_houses_array, large_image_array_filepath):
    i = 0
    while i < AMOUNT_OF_HOUSES:
        x = random.randint(0, 9)
        y = random.randint(0, 9)

        if field.small_image_array[x][y] == 0 and field.large_image_array[x][y] == 0:
            field.small_image_array[x][y] = small_images_of_houses_array[i]
            field.large_image_array[x][y] = large_images_of_houses_array[i]
            field.large_image_array_filepath[x][y] = large_image_array_filepath
            i += 1


def LoadImages(directory):
    array = []
    for filename in os.listdir(directory):
        image_path = f"{directory}/{filename}"
        image = PhotoImage(master=field.large_image_canvas, file=image_path)

        array.append(image)

    return array


def LoadImages_2(directory):
    array = []
    for filename in os.listdir(directory):
        image_path = f"{directory}/{filename}"
        image = PhotoImage(master=field.small_field_canvas, file=image_path)

        array.append(image)

    return array


def LoadPath(directory):
    array = []
    for filename in os.listdir(directory):
        array.append(f'{directory}/{filename}')

    return array


def LoadData(small_directory, large_directory):
    small_array = []
    large_array = []
    path_array = []

    for filename in sorted(os.listdir(small_directory)):
        image_path = f'{small_directory}/{filename}'
        image = PhotoImage(master=field.small_field_canvas, file=image_path)

        small_array.append(image)

    for filename in sorted(os.listdir(large_directory)):
        image_path = f'{large_directory}/{filename}'
        image = PhotoImage(master=field.large_image_canvas, file=image_path)

        large_array.append(image)
        path_array.append(f'{large_directory}/{filename}')

    return small_array, large_array, path_array


def LoadDataInArrays(small_images_directory, large_images_directory):
    small_images_of_houses_array = []
    large_images_of_houses_array = []
    large_image_array_filepath = []

    is_equal_len = False

    small_images_dir = sorted(os.listdir(small_images_directory))
    large_images_dir = sorted(os.listdir(large_images_directory))
    large_image_array_filepath = large_images_dir.copy()

    # print(large_image_array_filepath)

    for i in range(len(large_image_array_filepath)):
        filename = large_image_array_filepath[i]
        path = f'{large_images_directory}/{filename}'
        large_image_array_filepath[i] = path

    # print(large_image_array_filepath)

    if len(small_images_dir) == len(large_images_dir) == len(large_image_array_filepath):
        is_equal_len = True

    if is_equal_len:
        for i in range(len(small_images_dir)):
            is_path_good = False
            small_image_path = f'{small_images_directory}/{small_images_dir[i]}'
            large_image_path = f'{large_images_directory}/{large_images_dir[i]}'

            if large_image_path == large_image_array_filepath[i]:
                is_path_good = True

            # print(f'large_image_path: {large_image_path}\nlarge_image_array_filepath[i]: {large_image_array_filepath[i]:}')

            if not is_path_good:
                print("path is bad\nerror!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")

            small_image = PhotoImage(master=field.small_field_canvas, file=small_image_path)
            large_image = PhotoImage(master=field.large_image_canvas, file=large_image_path)

            small_images_of_houses_array.append(small_image)
            large_images_of_houses_array.append(large_image)

    return small_images_of_houses_array, large_images_of_houses_array, large_image_array_filepath


def HousesImagesInArray_2(small_images_of_houses_array, large_images_of_houses_array, large_image_array_filepath):
    i = 0
    while i < AMOUNT_OF_HOUSES:
        x = random.randint(0, 9)
        y = random.randint(0, 9)

        if field.small_image_array[x][y] == 0 and field.large_image_array[x][y] == 0:
            field.small_image_array[x][y] = small_images_of_houses_array[i]
            field.large_image_array[x][y] = large_images_of_houses_array[i]
            field.large_image_array_filepath[x][y] = large_image_array_filepath[i]
            i += 1


def ImagesInArray_2(small_images_array, large_images_array, large_image_array_filepath):
    # Filling array from directory
    x = y = 0

    # if len(small_images_array) != len(large_images_array):
    #     print(f'len(small_images_array) != len(large_images_array)\nerror!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!')

    for i in range(len(small_images_array)):
        is_done = False
        while not is_done:
            if field.small_image_array[x][y] == 0 and field.large_image_array[x][y] == 0:
                field.small_image_array[x][y] = small_images_array[i]
                field.large_image_array[x][y] = large_images_array[i]
                field.large_image_array_filepath[x][y] = large_image_array_filepath[i]
                is_done = True
            else:
                x += 1
                if x == 10:
                    x = 0
                    y += 1
                if y == 10:
                    break

        x += 1
        if x == 10:
            x = 0
            y += 1
        if y == 10:
            break

    # if len(small_images_array) != len(large_images_array):
    #     print(f'len(small_images_array) != len(large_images_array)\nerror!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!')
    #
    # for i in range(len(small_images_array)):
    #     is_done = False
    #     while not is_done:
    #         if field.small_image_array[x][y] == 0 and field.large_image_array[x][y] == 0:
    #             field.small_image_array[x][y] = small_images_array[i]
    #             field.large_image_array[x][y] = large_images_array[i]
    #             is_done = True
    #         else:
    #             y += 1
    #             if y == 10:
    #                 y = 0
    #                 x += 1
    #             if x == 10:
    #                 break
    #
    #     y += 1
    #     if y == 10:
    #         y = 0
    #         x += 1
    #     if x == 10:
    #         break


def MinesInArrays_2(mines_array, small_mines_images_dir, large_mines_images_dir):
    counter = 0

    small_temp_array = []
    large_temp_array = []

    for file in os.listdir(small_mines_images_dir):
        if counter < AMOUNT_OF_MINES:
            image_name = file
            image_path = f"{small_mines_images_dir}/{image_name}"
            image = PhotoImage(master=field.small_field_canvas, file=image_path)

            small_temp_array.append(image)

            counter += 1

    # print()
    # print()
    # print()
    # print()
    # print()
    # print()
    for z in range(AMOUNT_OF_MINES):
        mines_array[z].small_img = small_temp_array[z]

        # Add images in image array
        field.small_image_array[mines_array[z].array_x][mines_array[z].array_y] = small_temp_array[z]

        # print(f'mines_array[z].array_x][mines_array[z].array_y: {mines_array[z].array_x}, {mines_array[z].array_y}')
        # print(
        #     f'small_image_array[{mines_array[z].array_x}][{mines_array[z].array_y}]: {field.small_image_array[mines_array[z].array_x][mines_array[z].array_y]}')

    for i in range(len(mines_array)):
        field.mines_coord.append([mines_array[i].array_y, mines_array[i].array_x])

    counter = 0
    for file in os.listdir(large_mines_images_dir):
        if counter < AMOUNT_OF_MINES:
            image_name = file
            image_path = f"{large_mines_images_dir}/{image_name}"
            image = PhotoImage(master=field.large_image_canvas, file=image_path)

            large_temp_array.append(image)

            counter += 1

    for i in range(AMOUNT_OF_MINES):
        mines_array[i].large_img = large_temp_array[i]

        # Add images in image array
        field.large_image_array[mines_array[i].array_x][mines_array[i].array_y] = large_temp_array[i]


def main():
    # Creating the main window of an application
    win_size = f'{WINDOW_X}x{WINDOW_Y}'
    field.win.title("Sapper")
    field.win.configure(bg='gray')
    field.win.geometry(win_size)
    print(f'Amount of mines: {AMOUNT_OF_MINES}')
    print(f'Amount of houses: {AMOUNT_OF_HOUSES}')

    global btn
    btn = Button(field.win,
                 text="Search for mines",  # текст кнопки
                 background="#555",  # фоновый цвет кнопки
                 foreground="#ccc",  # цвет текста
                 padx="20",  # отступ от границ до содержимого по горизонтали
                 pady="8",  # отступ от границ до содержимого по вертикали
                 font="24",  # высота шрифта
                 command=click_button
                 )

    btn.place(x=10, y=560)

    # Create array with mines objects
    mines_array = []

    CostingOfCells()

    # Put mines on coordinates
    PutMines(mines_array)

    # # Add images of mines in arrays
    # MinesInArrays(mines_array, "../../files/small_mines_images", field.small_image_array, True)
    # MinesInArrays(mines_array, "../../files/large_mines_images", field.large_image_array, False)

    small_mines_images_dir = "E:/Projects/Pycharm Projects/sapper/files/small_mines_images"
    large_mines_images_dir = "E:/Projects/Pycharm Projects/sapper/files/large_mines_images"
    MinesInArrays_2(mines_array, small_mines_images_dir, large_mines_images_dir)

    # small_images_of_houses_array, large_images_of_houses_array, large_image_array_filepath = LoadAndMixImages(
    #     "../../files/small_images_houses",
    #     "../../files/large_images_houses")

    # small_images_of_houses_array, large_images_of_houses_array, large_image_array_filepath = LoadImages("../../files/small_images_houses", "../../files/large_images_houses")

    # small_images_of_houses_array = LoadImages("../../files/small_images_houses")
    # large_images_of_houses_array = LoadImages_2("../../files/large_images_houses")
    # large_image_array_filepath = LoadPath("../../files/large_images_houses")

    # small_images_of_houses_array, large_images_of_houses_array, large_image_array_filepath = LoadData("../../files/small_images_houses", "../../files/large_images_houses")

    small_images_of_houses_array, large_images_of_houses_array, large_image_array_filepath = LoadDataInArrays(
        "E:/Projects/Pycharm Projects/sapper/files/small_images_houses",
        "E:/Projects/Pycharm Projects/sapper/files/large_images_houses")

    # HousesImagesInArray(small_images_of_houses_array, field.small_image_array, [], False)
    # HousesImagesInArray(large_images_of_houses_array, field.large_image_array, large_image_array_filepath, True)

    HousesImagesInArray_2(small_images_of_houses_array, large_images_of_houses_array, large_image_array_filepath)

    # funct(small_images_of_houses_array, large_images_of_houses_array, large_image_array_filepath)

    # First check only for mines
    CheckForChainReaction()

    small_directory = "E:/Projects/Pycharm Projects/sapper/files/small_images"
    large_directory = "E:/Projects/Pycharm Projects/sapper/files/large_images"
    # small_images_array, large_images_array, large_image_array_filepath = LoadAndMixImages(small_directory,
    #                                                                                       large_directory)

    # small_images_array = LoadImages("../../files/small_images_houses")
    # large_images_array = LoadImages_2("../../files/large_images_houses")
    # large_image_array_filepath = LoadPath("../../files/large_images_houses")

    # small_images_array, large_images_array, large_image_array_filepath = LoadData(small_directory, large_directory)

    small_images_array, large_images_array, large_image_array_filepath = LoadDataInArrays(small_directory,
                                                                                          large_directory)

    # # Filling image arrays
    # ImagesInArray(small_images_array, field.small_image_array, [], False)
    # ImagesInArray(large_images_array, field.large_image_array, large_image_array_filepath, True)

    ImagesInArray_2(small_images_array, large_images_array, large_image_array_filepath)

    # Add arrow image to Player class
    images = []
    for file in os.listdir("../../files/arrow"):
        path = f"../../files/arrow/{file}"
        img = PhotoImage(master=field.small_field_canvas, file=path)
        images.append(img)

    player.arrow_east_image = images[0]
    player.arrow_north_image = images[1]
    player.arrow_south_image = images[2]
    player.arrow_west_image = images[3]

    # Filling window with images
    Fill(True)
    # Drawing arrow (player)
    image = player.arrow_east_image
    player.image_canvas_id = field.small_field_canvas.create_image(player.current_x, player.current_y, anchor=NW,
                                                                   image=image)

    # print("state of cell array:")
    # for el in field.state_of_cell_array:
    #     print(el)

    # for i in range(10):
    #     print(field.large_image_array_filepath[i])

    # Arrow(player.direction)
    # Rectangle(True, "None")
    # Rectangle()
    # Binding keyboard press to function
    # field.win.bind("<Key>", Action)
    # field.small_field_canvas.bind("<Button-1>", MouseClickEvent)

    # Starting mainloop for window
    field.win.mainloop()


if __name__ == '__main__':
    main()