import graph
from graph import *
import PIL
import os

from typing import NamedTuple
from contextlib import contextmanager
import types
import tempfile
import base64

from random import randrange, choice

consts = types.SimpleNamespace()
consts.VK_Q = 81
consts.VK_W = 87
consts.VK_A = 65
consts.VK_S = 83
consts.VK_D = 68

# объявление переменные для хранения картинки
hardcoded_image: bytes
hardcoded_bg: bytes


class Point(NamedTuple):
    """
    Вспомогательный класс для упрощения работы с координатами (сложение)
    """

    x: int | float
    y: int | float

    def __add__(self, other):
        if isinstance(other, self.__class__):
            return self.__class__(self.x + other.x, self.y + other.y)
        if isinstance(other, (int, float)):
            return self.__class__(self.x + other, self.y + other)
        return NotImplemented

    def __sub__(self, other):
        if isinstance(other, self.__class__):
            return self.__class__(self.x - other.x, self.y - other.y)
        if isinstance(other, (int, float)):
            return self.__class__(self.x - other, self.y - other)
        return NotImplemented

    def swap(self):
        return self.__class__(self.y, self.x)

    def transform(self, ref: "Point"):
        return self.__class__(self.x * ref.x, self.y * ref.y)


data = {
    "hero_pos": Point(0, 0),
    "finished": False,
    "hero_moved": False,
    "right": False,
    "last_right": False,
    "hero_img_left": None,
    "hero_img_right": None,
    "hero": None,
    "maze": [],
    "callbacks": [],
}


@contextmanager
def hardcoded_as_tmp(b64data: bytes, ext: str = ".png"):
    with tempfile.NamedTemporaryFile(
        mode="wb", suffix=ext, delete_on_close=False
    ) as fp:
        data = base64.b64decode(b64data)
        fp.write(data)
        fp.close()
        yield fp.name


@contextmanager
def tmp_flipped_img(src: str):
    """создание временнрого файла с зеркальной копией картинки"""

    # получаем оригинальное расширение
    _, ext = os.path.splitext(src)
    if not ext.startswith("."):
        ext = f".{ext}"

    # открытие
    image_obj = PIL.Image.open(src)
    rotated_image = image_obj.transpose(Image.FLIP_LEFT_RIGHT)  # зеркалирование
    with tempfile.NamedTemporaryFile(
        mode="wb", suffix=ext, delete_on_close=False
    ) as fp:
        fp.close()
        # сохранение
        rotated_image.save(fp.name)
        yield fp.name


def make_level(scene_sz):
    data["maze"] = maze_gen()
    box_sz = Point(scene_sz.x // len(data["maze"][0]), scene_sz.y // len(data["maze"]))

    data["hero_pos"] = find_start(data)
    print(data["hero_pos"])
    data["hero_img_right"] = PIL.ImageTk.PhotoImage(
        data["hero_img_right"].resize(box_sz)
    )
    data["hero_img_left"] = PIL.ImageTk.PhotoImage(data["hero_img_left"].resize(box_sz))
    changeProperty(data["hero"], image=data["hero_img_right"])
    data["hero_moved"] = True

    # brick = PIL.ImageTk.PhotoImage(
    #     PIL.Image.open("assets/brick.png").resize(box_sz)
    # )

    for i, row in enumerate(data["maze"]):
        for j, item in enumerate(row):
            if item < 1:
                continue
            p = Point(j, i).transform(box_sz)
            obj = image(*p, "assets/brick.png")
            # changeProperty(obj, image=brick)

    def update():
        # отрабатываем изменение направления
        if data["right"] != data["last_right"]:
            img = data["hero_img_right"] if data["right"] else data["hero_img_left"]
            changeProperty(data["hero"], image=img)
            data["last_right"] = data["right"]
        # отрисовка движения
        if data["hero_moved"]:
            moveObjectTo(data["hero"], *data["hero_pos"].transform(box_sz))
            data["hero_moved"] = False
        # победа
        if data["finished"]:
            data["callbacks"].remove(update)
            image(350, 350, "assets/win.png")
            penColor("blue")
            text("Красава!", 450, 450, font=("Arial", 30))

    data.setdefault("callbacks", []).append(update)


def find_start(data):
    for i in range(len(data["maze"])):
        if data["maze"][i][0] == 0:
            return Point(0, i)
    raise Exception("Не найдено начальное положение")


def move_hero(data, delta):
    new_pos = data["hero_pos"] + delta
    if (
        new_pos.x < 0
        or new_pos.y < 0
        or new_pos.x >= len(data["maze"])
        or new_pos.y >= len(data["maze"][0])
    ):
        return
    if data["maze"][new_pos.y][new_pos.x] > 0:
        return
    data["hero_pos"] = new_pos
    data["hero_moved"] = True
    if new_pos.x == len(data["maze"]) - 1:
        data["finished"] = True


def keyPressed(event):
    delta = None
    match event.keycode:
        case graph.VK_LEFT:
            delta = Point(-1, 0)
            data["right"] = False
        case graph.VK_RIGHT:
            delta = Point(1, 0)
            data["right"] = True
        case graph.VK_UP:
            delta = Point(0, -1)
        case graph.VK_DOWN:
            delta = Point(0, 1)
        case consts.VK_Q | graph.VK_ESCAPE:
            killTimer(data["update_timer"])
            close()
    if delta is not None:
        move_hero(data, delta)


def update():
    for callback in data["callbacks"]:
        callback()
    data["delta"] = Point(0, 0)


def maze_gen(row=4, col=4):
    """генератор карты
    взял с коментария https://stepik.org/lesson/502494/step/3?discussion=6527620&unit=494196
    """
    row = max(2 * row + 1, 3)
    col = max(2 * col + 1, 3)
    maze = [[2] * col]
    maze.extend([[2] + [1] * (col - 2) + [2] for _ in range(row - 2)])
    maze.append(maze[0])

    curr = (randrange(1, len(maze) - 1, 2), randrange(1, len(maze[0]) - 1, 2))
    path = [curr]
    maze[curr[0]][curr[1]] = 0

    while path:
        nexts = [
            (r1, c1, r2, c2)
            for r, c in zip((1, 0, -1, 0), (0, 1, 0, -1))
            if (
                (r1 := curr[0] + r) is None
                or (c1 := curr[1] + c) is None
                or (r2 := curr[0] + 2 * r) is None
                or (c2 := curr[1] + 2 * c) is None
                or 1 == maze[r1][c1] == maze[r2][c2]
            )
        ]
        if len(nexts):
            r1, c1, r2, c2 = choice(nexts)
            maze[r1][c1] = maze[r2][c2] = 0
            path.append((r2, c2))
        else:
            curr = path.pop()

    upd = {
        ("22", "20"): (None, "00"),
        ("02", "22"): ("00", None),
        ("11101", "00101", "11111", "10100", "10111"): (
            None,
            None,
            None,
            "10001",
            None,
        ),
        ("10111", "10100", "11111", "00101", "11101"): (
            None,
            "10001",
            None,
            None,
            None,
        ),
    }
    for key in upd:
        for i in range(len(maze) - len(key) + 1):
            for j in range(len(maze[0]) - len(key[0]) + 1):
                if all(
                    maze[i + k][j : j + len(v)] == list(map(int, v))
                    for k, v in enumerate(key)
                ):
                    for k, v in filter(lambda x: x[1], enumerate(upd[key])):
                        maze[i + k][j : j + len(v)] = list(map(int, v))

    return maze


def main():
    scene_sz = Point(1000, 1000)
    canvasSize(*scene_sz)

    # рисуем фон
    # with hardcoded_as_tmp(hardcoded_bg) as bg_filename:
    image(0, 0, "assets/bg1k.png")

    hero_img = PIL.Image.open("assets/ghost.png")
    data["hero_img_left"] = hero_img
    data["hero_img_right"] = hero_img.transpose(Image.FLIP_LEFT_RIGHT)
    data["hero"] = image(0, 0, "assets/ghost.png")

    make_level(scene_sz)

    data["update_timer"] = onTimer(update, 40)
    onKey(keyPressed)
    run()


main()