from typing import Optional


class Cell:
    """Класс отвечает за хранение характеристик поля лабиринта"""

    def __init__(
        self,
        x: int,
        y: int,
        is_wall: bool = False,
        is_start: bool = False,
        is_exit: bool = False,
    ):
        """
        :param x: Координата поля по оси X
        :type x: int
        :param y: Координата поля по оси Y
        :type y: int
        :param is_wall: Является ли поле **стеной**, defaults to False
        :type is_wall: bool, optional
        :param is_start: Является ли поле **началом**, defaults to False
        :type is_start: bool, optional
        :param is_exit: Является ли поле **концом**, defaults to False
        :type is_exit: bool, optional
        """
        self.x = x
        self.y = y
        self.is_wall = is_wall
        self.is_start = is_start
        self.is_exit = is_exit

    def isPossible(self) -> bool:
        """Проверка возможности перемещения в это поле

        :return: Если перемещение возможно, то `True`, иначе `False`
        :rtype: bool
        """
        return not self.is_wall


class Maze:
    def __init__(
        self,
        size: tuple[int, int] = (10, 10),
        start_point: tuple[int, int] = (0, 0),
        exit_point: tuple[int, int] = (-1, -1),
    ):
        # Установка размеров лабиринта
        self._width = size[0]
        self._height = size[1]

        # Установка значения стартового поля в лабиринте
        self._start_x = start_point[0]
        self._start_y = start_point[1]

        # Установка значения выходного поля в лабиринте
        self._exit_x = self._width - 1 if exit_point[0] == -1 else exit_point[0]
        self._exit_y = self._height - 1 if exit_point[1] == -1 else exit_point[1]

        # Создание двумерного списка лабиринта
        self._map = [
            [Cell(x, y) for x in range(self._width)] for y in range(self._height)
        ]

        # Проверяем, что координаты старта находятся в области лабиринта
        if self._check_point_in_map(self._start_x, self._start_y):
            self._map[self._start_y][self._start_x].is_start = True
        else:
            raise ValueError(
                f"Координата точки старта задана вне области лабиринта: ({self._start_x}, {self._start_y}) not in ({self._width}, {self._height})"
            )

        # Проверяем, что координаты выхода находятся в области лабиринта
        if not self._check_point_in_map(self._exit_x, self._exit_y):
            raise ValueError(
                f"Координата точки выхода задана вне области лабиринта: ({self._start_x}, {self._start_y}) not in ({self._width}, {self._height})"
            )
        self._map[self._exit_y][self._exit_x].is_exit = True

    def _check_point_in_map(self, x: int, y: int) -> bool:
        return (0 <= x < self._width) and (0 <= y < self._height)

    def get_cell(self, x: int, y: int) -> Optional[Cell]:
        if not self._check_point_in_map(x, y):
            raise ValueError(
                f"Указанные координаты выходят за границы лабиринта: ({x}, {y}) not in ({self._width}, {self._height})"
            )
        return self._map[y][x]

    def get_neighbors(self, x: int, y: int) -> Optional[list[Cell]]:
        vector_x = [0, 1, 0, -1]
        vector_y = [1, 0, -1, 0]

        neighbors = []

        for vec_x, vec_y in zip(vector_x, vector_y):
            temp_x, temp_y = x + vec_x, y + vec_y
            if self._check_point_in_map(temp_x, temp_y):
                neighbors.append(self._map[temp_y][temp_x])
        
        return neighbors