logic.py

import json
import tkinter as tk
from functools import lru_cache
from tkinter import filedialog
from typing import Any, Callable, Dict, Optional, Tuple, List
from constant import Max_len
import numpy as np

from image_handler import slider_background


class Shape:
    def __init__(self, canvas: tk.Canvas, radius: int, color: str) -> None:
        """
        Инициализирует объект Shape с заданным холстом, радиусом и цветом.

        Args:
            canvas (tk.Canvas): Холст для отрисовки фигуры.
            radius (int): Радиус фигуры.
            color (str): Цвет фигуры (например, "#RRGGBB").
        """
        self.canvas: tk.Canvas = canvas
        self.radius: int = radius
        self.color: str = color

    def clone(self, x: int, y: int) -> int:
        """
        Создает и рисует фигуру (овал) на холсте в указанной точке.

        Args:
            x (int): Координата x центра фигуры.
            y (int): Координата y центра фигуры.

        Returns:
            int: ID созданной фигуры на холсте.
        """
        data_figure_id: int = self.canvas.create_oval(
            x - self.radius, y - self.radius,
            x + self.radius, y + self.radius,
            fill=self.color, outline='#4f4f4f'
        )
        # Перемещаем фигуру на задний план, чтобы она не перекрывала другие элементы
        self.canvas.tag_lower(data_figure_id, 1)
        return data_figure_id


class GenerateRegion:
    """
    Класс для генерации и управления регионом данных на интерактивном графике.
    Отвечает за отрисовку фигур, обновление статистики и линии корреляции.
    """

    def __init__(
            self,
            canvas: tk.Canvas,
            shape: Shape,
            dispersion_scalar: float,
            plot_size: Tuple[int, int],
            stats_label: tk.Label
    ) -> None:
        """
        Инициализирует регион генерации данных для интерактивного графика.

        Args:
            canvas (tk.Canvas): Холст, на котором отображаются данные.
            shape (Shape): Объект Shape для создания графических фигур.
            dispersion_scalar (float): Масштаб для расчета разброса (dispersion).
            plot_size (Tuple[int, int]): Размеры области графика (ширина, высота).
            stats_label (tk.Label): Метка для отображения статистик.
        """
        self.canvas: tk.Canvas = canvas
        self.shape: Shape = shape
        self.dispersion_scalar: float = dispersion_scalar
        self.plot_size: Tuple[int, int] = plot_size
        self.stats_label: tk.Label = stats_label
        self.stats_label.place(relx=0.5, rely=0.0, anchor="n")
        self.dispersion: int = 0
        self.intensive: int = 0
        # Предварительное создание фигур для переключения между кругом и прямоугольником
        self.circle_form: int = self.canvas.create_oval(0, 0, 0, 0)
        self.rectangle_form: int = self.canvas.create_rectangle(0, 0, 0, 0)
        self.current_form: int = self.circle_form
        self.square_dispersion: int = self.dispersion ** 2
        self.show_dispersion: bool = True
        self.show_corr: bool = False
        self.eraser: bool = False
        # Создаем линию для отображения динамической корреляции (по умолчанию скрыта)
        self.dynamic_corr_line: int = self.canvas.create_line(0, 0, 0, 0, fill="red", width=2)
        self.dynamic_corr: DynamicCorrelation = DynamicCorrelation(plot_size[0])
        self.pixel_array: PixelArray = PixelArray(*plot_size)

    def change_position(self, x: int, y: int) -> None:
        """
        Обновляет позицию текущей фигуры на холсте при движении курсора.

        Args:
            x (int): Новая координата x.
            y (int): Новая координата y.
        """
        if self.dispersion != 0 and self.show_dispersion:
            coords = self.get_figure_coords(x, y, self.dispersion)
            self.canvas.coords(self.current_form, *coords)

    def hide_figure(self) -> None:
        """
        Скрывает фигуру, убирая её контур, чтобы она не была видна.
        """
        self.canvas.itemconfig(self.current_form, outline='')

    def show_figure(self) -> None:
        """
        Показывает фигуру, восстанавливая её контур, если она должна отображаться.
        """
        if self.dispersion != 0 and self.show_dispersion:
            self.canvas.itemconfig(self.current_form, outline='black')

    def switch_correlation(self) -> None:
        """
        Переключает отображение линии корреляции и метки коэффициента корреляции.
        """
        if self.show_corr:
            self.canvas.itemconfig(self.dynamic_corr_line, state="hidden")
            self.show_corr = False
        else:
            self.canvas.itemconfig(self.dynamic_corr_line, state="normal")
            self.show_corr = True
            self.update_corr_line()

    def update_corr_line(self) -> None:
        """
        Обновляет коэффициент корреляции и положение линии корреляции, если она отображается.
        """
        if self.show_corr:
            data = self.dynamic_corr.get_correlation_line()
            if data:
                self.canvas.coords(self.dynamic_corr_line, *data)

    def update_stats(self) -> None:
        """
        Обновляет статистики на экране.
        """
        self.stats_label.config(
            text=f"Mx={round(self.dynamic_corr.mean_x / self.plot_size[0], 2)},"
                 f" My={round(self.dynamic_corr.mean_y / self.plot_size[0], 2)},"
                 f" Stdx={round(self.dynamic_corr.std_x / self.plot_size[0], 2)},"
                 f" Stdy={round(self.dynamic_corr.std_y / self.plot_size[0], 2)},"
                 f" Сorr={min(round(self.dynamic_corr.correlation, 2), 1.0)}")

    def switch_figure(self) -> None:
        """
        Переключает текущую форму между прямоугольником и окружностью.
        """

        if self.current_form == self.rectangle_form:
            self.current_form = self.circle_form
        else:
            self.current_form = self.rectangle_form

    def add_data(self, x: int, y: int) -> None:
        """
        Добавляет данные (фигуру) в регион. Если dispersion не равен нулю, данные генерируются
        случайным образом внутри области, определяемой dispersion.

        Args:
            x (int): Координата x точки, где пользователь кликнул.
            y (int): Координата y точки, где пользователь кликнул.
        """
        if self.dispersion != 0:
            x1, y1, x2, y2 = self.get_figure_coords(x, y, self.dispersion)
            # Ограничиваем случайное значение x в пределах графика
            data_x = np.random.randint(max(0, x1), min(self.plot_size[0], x2))
            if self.current_form == self.circle_form:
                # Для окружности рассчитываем корректные y-координаты, используя квадрат dispersion
                y1, y2 = self.get_circle_coords(y, x, data_x, self.square_dispersion)
            # Если y1 и y2 равны, используем одно значение; иначе выбираем случайное значение в диапазоне
            data_y = y1 if y1 == y2 else np.random.randint(max(0, y1), min(self.plot_size[1], y2))
        else:
            data_x, data_y = x, y
        data_x, data_y = int(data_x), int(data_y)
        if not self.pixel_array.is_crowded(data_x, data_y):
            shape_id: int = self.shape.clone(data_x, data_y)
            self.pixel_array.add(data_x, data_y, shape_id)
            # Корректировка y для оси координат
            self.dynamic_corr.add(data_x, self.pixel_array.correct_y(data_y))
            self.update_corr_line()
            self.update_stats()

    def del_data(self, x: int, y: int) -> None:
        """
        Удаляет данные (фигуры) в области, определяемой координатами и dispersion.

        Args:
            x (int): Координата x центра области.
            y (int): Координата y центра области.
        """
        x1, y1, x2, y2 = self.get_figure_coords(x, y, self.dispersion)
        # Ограничиваем область в пределах графика
        x1, y1, x2, y2 = max(0, x1), max(0, y1), min(x2, self.plot_size[0]), min(y2, self.plot_size[1])
        if self.current_form == self.rectangle_form:
            data = self.pixel_array.del_data(x1, y1, x2 + 1, y2 + 1)
        else:
            data = self.pixel_array.del_data(x1, y1, x2 + 1, y2 + 1, self.dispersion)
        if data[0] is not None:
            for fig_id, deleted_x, deleted_y in zip(*data):
                self.canvas.delete(fig_id)
                self.dynamic_corr.remove(deleted_x, self.pixel_array.correct_y(deleted_y))
            self.update_corr_line()
            self.update_stats()

    @lru_cache
    def get_figure_coords(self, x: int, y: int, dispersion: int) -> Tuple[int, int, int, int]:
        """
        Вычисляет координаты фигуры (прямоугольника), основанные на центральной точке и dispersion.

        Args:
            x (int): Координата x центра.
            y (int): Координата y центра.
            dispersion (int): Отступ от центра для вычисления координат.

        Returns:
            Tuple[int, int, int, int]: Координаты (x1, y1, x2, y2) фигуры.
        """
        return x - dispersion, y - dispersion, x + dispersion, y + dispersion

    @lru_cache
    def get_circle_coords(self, y: int, x: int, data_x: int, square_dispersion: int) -> Tuple[float, float]:
        """
        Вычисляет координаты по оси y для окружности, чтобы сохранить форму круга.

        Args:
            y (int): Центр окружности по оси y.
            x (int): Центр окружности по оси x.
            data_x (int): Случайно выбранная координата x для точки внутри окружности.
            square_dispersion (int): Квадрат текущего dispersion.

        Returns:
            Tuple[float, float]: Верхняя и нижняя границы по оси y для окружности.
        """
        cos = abs(x - data_x)
        sin = np.sqrt(square_dispersion - cos ** 2)
        return y - sin, y + sin

    def set_dispersion(self, value: float) -> None:
        """
        Устанавливает значение dispersion на основе входного значения и масштабного коэффициента.

        Args:
            value (float): Значение слайдера для dispersion.
        """
        self.dispersion = 0 if not value else int(value * self.dispersion_scalar)
        self.square_dispersion = self.dispersion ** 2

    def set_intensive(self, value: float) -> None:
        """
        Устанавливает интенсивность (задержку) для повторного добавления данных.

        Args:
            value (float): Значение слайдера для интенсивности.
        """
        self.intensive = 0 if not value else int((1.01 - value) * 100)  # задержка в миллисекундах

    def switch_dispersion(self) -> None:
        """
        Переключает видимость dispersion (разброса) данных.
        """
        self.show_dispersion = not self.show_dispersion

    def switch_eraser(self) -> None:
        """
        Переключает режим "ластика" для удаления данных.
        """
        self.eraser = not self.eraser


class DynamicCorrelation:
    """
    Класс для динамического расчёта коэффициента корреляции Пирсона.
    Поддерживает добавление и удаление точек.
    """

    def __init__(self, max_value: int) -> None:
        """
        Args:
            max_value (int): Максимальное значение по оси X для линии корреляции.
        """
        self.max = max_value
        self.points: list[tuple[float, float]] = []  # храним все точки

        # статистики
        self.n: int = 0
        self.mean_x: float = 0.0
        self.mean_y: float = 0.0
        self.Sxx: float = 0.0
        self.Syy: float = 0.0
        self.Sxy: float = 0.0

        # готовые значения
        self.std_x: float = 0.0
        self.std_y: float = 0.0
        self.covariance: float = 0.0
        self.correlation: float = 0.0

    # ==============================
    # Добавление точки
    # ==============================
    def add(self, x_val: float, y_val: float) -> None:
        self.points.append((x_val, y_val))
        self._recompute()

    # ==============================
    # Удаление точки
    # ==============================
    def remove(self, x_val: float, y_val: float) -> None:
        try:
            self.points.remove((x_val, y_val))
        except ValueError:
            # если такой точки нет
            return
        self._recompute()

    # ==============================
    # Пересчёт статистик
    # ==============================
    def _recompute(self) -> None:
        self.n = len(self.points)
        if self.n < 2:
            self.mean_x = self.mean_y = 0.0
            self.Sxx = self.Syy = self.Sxy = 0.0
            self.std_x = self.std_y = self.covariance = self.correlation = 0.0
            return

        xs, ys = zip(*self.points)
        xs = np.array(xs, dtype=float)
        ys = np.array(ys, dtype=float)

        self.mean_x = float(xs.mean())
        self.mean_y = float(ys.mean())

        dx = xs - self.mean_x
        dy = ys - self.mean_y

        self.Sxx = float((dx**2).sum())
        self.Syy = float((dy**2).sum())
        self.Sxy = float((dx * dy).sum())

        self.std_x = np.sqrt(self.Sxx / (self.n - 1))
        self.std_y = np.sqrt(self.Syy / (self.n - 1))
        self.covariance = self.Sxy / (self.n - 1)

        if self.std_x > 0 and self.std_y > 0:

            self.correlation = self.covariance / (self.std_x * self.std_y)
        else:
            self.correlation = 0.0

    # ==============================
    # Линия корреляции
    # ==============================
    def get_correlation_line(self) -> Optional[Tuple[float, float, float, float]]:
        """
        Возвращает координаты линии корреляции (x1, y1, x2, y2),
        или None, если данных недостаточно.
        """
        if self.n < 2 or self.correlation == 0.0:
            return None

        try:
            # Отрицательный знак применяется для корректного графического отображения.
            slope = -self.Sxy / self.Sxx  # наклон МНК
        except ZeroDivisionError:
            return None

        intercept = self.mean_y - slope * self.mean_x

        x_start, x_end = 0, self.max
        y_start = slope * x_start + intercept
        y_end = slope * x_end + intercept

        return x_start, y_start, x_end, y_end


class PixelArray:
    """
    Класс для хранения и управления данными о пикселях (ID фигур) в заданной области.
    """

    def __init__(self, max_x: int, max_y: int, max_len: int = Max_len) -> None:
        """
        Инициализирует массив пикселей для хранения ID фигур.

        Args:
            max_x (int): Максимальная ширина области.
            max_y (int): Максимальная высота области.
            max_len (int, optional): Максимальное количество элементов в одном пикселе. По умолчанию 100.
        """
        self.max_x: int = max_x + 1
        self.max_y: int = max_y + 1
        self.max_len: int = max_len
        self.array: np.ndarray = np.zeros((self.max_x, self.max_y, self.max_len + 1), dtype=np.int32)

    def correct_y(self, y: int) -> int:
        """
        Корректирует координату y для отображения (переворачивает ось).

        Args:
            y (int): Исходная координата y.

        Returns:
            int: Скорректированная координата y.
        """
        return self.max_y - y

    def norm_data(self, x: int, y: int) -> Tuple[float, float]:
        """
        Нормализует координаты в диапазон [0, 1].

        Args:
            x (int): Координата x.
            y (int): Координата y.

        Returns:
            Tuple[float, float]: Нормализованные координаты.
        """
        return x / self.max_x, y / self.max_y

    def add(self, x: int, y: int, shape_id: int) -> None:
        """
        Добавляет ID фигуры в массив пикселей по заданным координатам.

        Args:
            x (int): Координата x.
            y (int): Координата y.
            shape_id (int): ID фигуры, добавляемой на холст.
        """
        self.array[x, y, 0] += 1
        self.array[x, y, self.array[x, y, 0]] = shape_id

    def del_data(
            self, x1: int, y1: int, x2: int, y2: int, radius: Optional[int] = None):
        """
        Удаляет данные (фигуры) из заданного регионального среза массива пикселей.

        Args:
            x1 (int): Левая граница области.
            y1 (int): Верхняя граница области.
            x2 (int): Правая граница области.
            y2 (int): Нижняя граница области.
            radius (Optional[int], optional): Радиус для фильтрации точек внутри области.
                Если задан, удаляются только точки внутри данного радиуса.

        Returns:
            Tuple[np.ndarray, np.ndarray, np.ndarray]:
                Кортеж, содержащий:
                - last_fig_ids: массив удаленных ID фигур,
                - массив глобальных x-координат удаленных точек,
                - массив глобальных y-координат удаленных точек.
        """
        region: np.ndarray = self.array[x1:x2, y1:y2]
        nrows, ncols, _ = region.shape

        # Генерируем индексы для каждой ячейки в срезе
        i, j = np.indices((nrows, ncols))
        last_elements = region[..., 0].copy()

        if radius is not None:
            # Центр среза
            center_x = x1 + nrows // 2
            center_y = y1 + ncols // 2

            # Расчет расстояний от центра для каждого элемента
            distances = np.sqrt((x1 + i - center_x) ** 2 + (y1 + j - center_y) ** 2)

            # Выбираем элементы, находящиеся внутри заданного радиуса
            mask = distances <= radius
        else:
            mask = np.ones((nrows, ncols), dtype=bool)

        # Фильтруем элементы, где уже есть данные (last_elements > 0)
        valid_mask = mask & (last_elements > 0)
        last_fig_ids = region[valid_mask, last_elements[valid_mask]].copy().ravel()

        changed_indices = np.column_stack(np.where(valid_mask)) + [x1, y1]

        # Обнуляем удаленные данные в массиве
        region[valid_mask, last_elements[valid_mask]] = 0

        # Обновляем количество элементов в каждом пикселе
        last_elements[valid_mask] -= 1
        region[..., 0] = np.maximum(0, last_elements)
        return last_fig_ids, changed_indices[:, 0], changed_indices[:, 1]

    def is_crowded(self, x: int, y: int) -> bool:
        """
        Проверяет, достигнуто ли максимальное количество элементов в пикселе.

        Args:
            x (int): Координата x.
            y (int): Координата y.

        Returns:
            bool: True, если количество элементов достигло max_len, иначе False.
        """
        return self.array[x, y, 0] == self.max_len

    def export(self) -> None:
        """
        Экспортирует данные массива пикселей в JSON файл.
        Собирает координаты всех пикселей с данными и сохраняет их в выбранный файл.
        """
        # Находим индексы пикселей, где есть хотя бы один элемент
        x_coords, y_coords = np.where(self.array[:, :, 0] > 0)
        x_data: List[float] = []
        y_data: List[float] = []
        for x, y in zip(x_coords, y_coords):
            count = self.array[x, y, 0]
            y = self.correct_y(y)
            x, y = self.norm_data(x, y)
            x_data.extend([x] * count)
            y_data.extend([y] * count)

        file_path: str = filedialog.asksaveasfilename(
            defaultextension=".json",
            filetypes=[("Json files", "*.json"), ("All files", "*.*")]
        )
        if file_path:
            with open(file_path, "w") as json_file:
                json.dump({"x": x_data, "y": y_data}, json_file, indent=4)


class InteractivePlot:
    def __init__(
            self,
            canvas: tk.Canvas,
            coord_label: tk.Label,
            stats_label: tk.Label,
            shape: Shape,
            dispersion_scalar: float,
            plot_size: Tuple[int, int]
    ) -> None:
        """
        Инициализирует интерактивный график с обработчиками событий.

        Args:
            canvas (tk.Canvas): Холст для графика.
            coord_label (tk.Label): Метка для отображения координат курсора.
            stats_label (tk.Label): Метка для отображения статистик.
            shape (Shape): Объект Shape для создания фигур.
            dispersion_scalar (float): Коэффициент масштабирования для dispersion.
            plot_size (Tuple[int, int]): Размеры графика (ширина, высота).
        """
        self.canvas: tk.Canvas = canvas
        self.coord_label: tk.Label = coord_label
        self.generate_region: GenerateRegion = GenerateRegion(canvas, shape, dispersion_scalar, plot_size, stats_label)
        self.is_push: bool = False
        self.is_hover: bool = False
        self.x_position: int = 0
        self.y_position: int = 0

        # Привязка событий для обработки наведения, нажатия, отпускания и движения мыши
        for event, func in zip(
                ("<Enter>", "<Leave>", "<Button-1>", "<ButtonRelease-1>", "<Motion>"),
                (self.on_hover, self.on_leave, self.push_logic, self.unpush_logic, self.move_logic)
        ):
            self.canvas.bind(event, func)

    def on_hover(self, event: tk.Event) -> None:
        """
        Обработчик наведения мыши на холст.
        Отображает фигуру и метку с координатами.
        """
        self.is_hover = True
        self.generate_region.show_figure()
        self.coord_label.place(relx=1.0, rely=1.0, anchor="se")

    def push_logic(self, event: tk.Event) -> None:
        """
        Обработчик начала нажатия на холст.
        Устанавливает флаг нажатия и запускает процесс добавления или удаления данных.
        """
        self.is_push = True
        self.holding()

    def holding(self) -> None:
        """
        Рекурсивно вызывает добавление или удаление данных в зависимости от режима.
        Если интенсивность задана, повторяет действие через заданный интервал.
        """
        if self.generate_region.eraser:
            self.generate_region.del_data(self.x_position, self.y_position)
        else:
            self.generate_region.add_data(self.x_position, self.y_position)
        if self.is_push and self.generate_region.intensive != 0:
            self.canvas.after(self.generate_region.intensive, self.holding)

    def unpush_logic(self, event: tk.Event) -> None:
        """
        Обработчик отпускания кнопки мыши.
        Сбрасывает флаг нажатия.
        """
        self.is_push = False

    def on_leave(self, event: tk.Event) -> None:
        """
        Обработчик ухода курсора с холста.
        Скрывает фигуру и убирает метку координат.
        """
        self.is_hover = False
        if self.is_push:
            self.unpush_logic(event)
        self.generate_region.hide_figure()
        self.coord_label.place_forget()

    def move_logic(self, event: tk.Event) -> None:
        """
        Обработчик движения мыши по холсту.
        Обновляет позицию фигуры и метки координат.
        """
        if self.is_hover:
            self.generate_region.change_position(event.x, event.y)
            self.coord_label.config(text=f"(x={event.x}, y={event.y})")
            self.x_position = event.x
            self.y_position = event.y


class ButtonVisual:
    """
    Базовый класс для визуального отображения кнопок.
    Определяет логику смены состояний кнопки (наведение, нажатие, отпускание).
    """

    def __init__(
            self,
            base_status: Any,
            active_button_status: Optional[Any] = None,
            push_button_status: Optional[Any] = None,
            offset: Tuple[int, int] = (0, 0)
    ) -> None:
        """
        Инициализирует визуальное представление кнопки.

        Args:
            base_status (Any): Изображение или состояние кнопки в базовом виде.
            active_button_status (Optional[Any]): Состояние кнопки при наведении.
                Если не задано, используется base_status.
            push_button_status (Optional[Any]): Состояние кнопки при нажатии.
                Если не задано, используется base_status.
            offset (Tuple[int, int]): Смещение кнопки при нажатии.
        """
        self.base_status: Any = base_status
        self.active_button_status: Any = active_button_status or base_status
        self.push_button_status: Any = push_button_status or base_status
        self.offset: Tuple[int, int] = offset
        self.is_available: bool = True
        self.is_pushed: bool = False
        self.is_active: bool = False
        # Словарь, связывающий события с соответствующими методами-обработчиками
        self.func_dict: Dict[str, Callable[[tk.Canvas, int], None]] = {
            "<Enter>": self.on_hover,
            "<Leave>": self.on_leave,
            "<Button-1>": self.push_logic,
            "<ButtonRelease-1>": self.unpush_logic
        }

    def handler(self, canvas: tk.Canvas, figure: int, event: str) -> None:
        """
        Вызывает обработчик события, соответствующий указанному событию.

        Args:
            canvas (tk.Canvas): Холст, на котором происходит событие.
            figure (int): ID фигуры кнопки на холсте.
            event (str): Событие, например "<Enter>" или "<Button-1>".
        """
        self.func_dict[event](canvas, figure)

    @staticmethod
    def changer(canvas: tk.Canvas, figure: int, fill: Any) -> None:
        """
        Изменяет визуальное состояние кнопки, устанавливая новое изображение или состояние.

        Args:
            canvas (tk.Canvas): Холст, на котором находится кнопка.
            figure (int): ID фигуры кнопки.
            fill (Any): Новое изображение или состояние для кнопки.
        """
        canvas.itemconfig(figure, image=fill)

    def on_hover(self, canvas: tk.Canvas, figure: int) -> None:
        """
        Обработчик наведения мыши на кнопку.
        Изменяет состояние кнопки на активное, если кнопка не нажата.

        Args:
            canvas (tk.Canvas): Холст с кнопкой.
            figure (int): ID фигуры кнопки.
        """
        self.is_active = True
        if not self.is_pushed:
            self.changer(canvas, figure, self.active_button_status)

    def push_logic(self, canvas: tk.Canvas, figure: int) -> None:
        """
        Обработчик начала нажатия на кнопку.
        Изменяет состояние кнопки на нажатое и смещает её.

        Args:
            canvas (tk.Canvas): Холст с кнопкой.
            figure (int): ID фигуры кнопки.
        """
        if not self.is_pushed:
            self.is_pushed = True
            self.changer(canvas, figure, self.push_button_status)
            canvas.move(figure, *self.offset)

    def unpush_logic(self, canvas: tk.Canvas, figure: int) -> None:
        """
        Обработчик отпускания кнопки.
        Возвращает кнопку в активное или базовое состояние, а также возвращает её в исходное положение.

        Args:
            canvas (tk.Canvas): Холст с кнопкой.
            figure (int): ID фигуры кнопки.
        """
        if self.is_active:
            self.changer(canvas, figure, self.active_button_status)
        else:
            self.changer(canvas, figure, self.base_status)
        x, y = self.offset
        canvas.move(figure, -x, -y)
        self.is_pushed = False

    def on_leave(self, canvas: tk.Canvas, figure: int) -> None:
        """
        Обработчик ухода курсора с кнопки.
        Возвращает кнопку в базовое состояние, если она не нажата.

        Args:
            canvas (tk.Canvas): Холст с кнопкой.
            figure (int): ID фигуры кнопки.
        """
        self.is_active = False
        if not self.is_pushed:
            self.changer(canvas, figure, self.base_status)


class SwitchVisual(ButtonVisual):
    """
    Класс для визуального отображения переключаемых кнопок.
    При повторном нажатии кнопка переключается между активным и неактивным состоянием.
    """

    def push_logic(self, canvas: tk.Canvas, figure: int) -> None:
        """
        При нажатии переключает состояние кнопки: если кнопка не нажата, устанавливает состояние нажатия,
        иначе возвращает кнопку в исходное состояние.

        Args:
            canvas (tk.Canvas): Холст с кнопкой.
            figure (int): ID фигуры кнопки.
        """
        if not self.is_pushed:
            self.is_pushed = True
            self.changer(canvas, figure, self.push_button_status)
            canvas.move(figure, *self.offset)
        else:
            super().unpush_logic(canvas, figure)

    def unpush_logic(self, canvas: tk.Canvas, figure: int) -> None:
        """
        Для переключаемых кнопок метод unpush_logic не выполняет никаких действий,
        так как переключение состояния происходит в push_logic.
        """
        pass


class BasicButton:
    """
    Класс для создания базовой кнопки на Canvas.
    Создаёт изображение и текст, а также привязывает обработчики событий.
    """

    def __init__(
            self,
            canvas: tk.Canvas,
            x: int,
            y: int,
            figure: Any,
            visual: ButtonVisual,
            selected_func: Callable,
            anchor: str = "n",
    ) -> None:
        """
        Инициализация кнопки.

        Args:
            canvas (tk.Canvas): Канвас для размещения кнопки.
            x (int): X-координата центра кнопки.
            y (int): Y-координата центра кнопки.
            figure (Any): Изображение для кнопки.
            visual (ButtonVisual): Объект, отвечающий за визуальное поведение кнопки.
            selected_func (Callable): Объект, содержащий логику кнопки.
            anchor (str): Точка привязки.
        """
        self.canvas = canvas
        # Создаём изображение кнопки и текст на канвасе
        self.figure = self.canvas.create_image(x, y, image=figure, anchor=anchor)
        self.visual = visual
        self.selected_func = selected_func

        # Привязка событий для обработки наведения, нажатия и отпускания
        for event, func in zip(
                ("<Enter>", "<Leave>", "<Button-1>", "<ButtonRelease-1>"),
                (self.on_hover, self.on_leave, self.base_push_logic, self.unpush_logic)
        ):
            self.canvas.tag_bind(self.figure, event, func)

    def on_hover(self, event: tk.Event) -> None:
        """
        Обработчик наведения курсора.
        """
        self.visual.handler(self.canvas, self.figure, "<Enter>")

    def base_push_logic(self, event: tk.Event) -> None:
        """
        Обработчик начала нажатия кнопки.
        """
        self.visual.handler(self.canvas, self.figure, "<Button-1>")

    def unpush_logic(self, event: tk.Event) -> None:
        """
        Обработчик отпускания кнопки.
        При этом вызывается логика кнопки, если она доступна.
        """
        if self.visual.is_available:
            self.selected_func()
        self.visual.handler(self.canvas, self.figure, "<ButtonRelease-1>")

    def on_leave(self, event: tk.Event) -> None:
        """
        Обработчик ухода курсора с кнопки.
        """
        self.visual.handler(self.canvas, self.figure, "<Leave>")


class Slider(BasicButton):
    """
    Класс для создания слайдера на Canvas.
    Слайдер состоит из заднего фона, меток (если заданы) и движущегося элемента.
    """

    def __init__(
            self,
            canvas: tk.Canvas,
            back_ground: Any,
            color: Tuple[int, int, int],
            x: int,
            y: int,
            figure: Any,
            visual: ButtonVisual,
            selected_func: Callable,
            anchor: str = "center"
    ) -> None:
        """
        Инициализирует слайдер.

        Args:
            canvas (tk.Canvas): Канвас, на котором размещается слайдер.
            back_ground (Any): Изображение или объект, задающий фон слайдера.
            color (Tuple[int, int, int]): Цвет, используемый для генерации заднего фона слайдера.
            x (int): X-координата размещения.
            y (int): Y-координата размещения.
            figure (Any): Изображение для движущегося элемента слайдера.
            visual (ButtonVisual): Визуальное поведение слайдера.
            selected_func (Callable): Функция обработки нажатия.
            anchor (str): Точка привязки.
        """
        # Извлекаем размеры заднего фона слайдера
        self.width, self.height = back_ground.size

        self._init_side_variables(figure, back_ground)

        # Инициализация канваса слайдера
        init_data = self._init_slider(canvas, color, back_ground, anchor, x, y, figure, visual, selected_func)
        super().__init__(*init_data, anchor="center")

        # Привязка обработчика перетаскивания к движению мыши
        self.canvas.tag_bind(self.figure, "<B1-Motion>", self.on_drag)

        self.position = self.min_pos
        self.update_slider_position()

    def _init_side_variables(
            self,
            figure: Any,
            back_ground: Any
    ) -> None:
        """
        Инициализирует базовые переменные для расчёта позиции слайдера.

        Args:
            figure (Any): Изображение движущегося элемента.
            back_ground (Any): Объект заднего фона слайдера.
        """
        self.width //= 2
        self.min_pos = figure.width() // 2
        self.max_pos = back_ground.size[0] // 2 - figure.width() // 2
        self.slider_range = self.max_pos - self.min_pos

    def _init_slider(
            self,
            canvas: tk.Canvas,
            color: Tuple[int, int, int],
            back_ground: Any,
            anchor: str,
            x: int,
            y: int,
            figure: Any,
            visual: ButtonVisual,
            selected_func: Callable
    ):
        """
        Инициализирует канвас для слайдера, создаёт задний фон и накладываемое изображение.

        Args:
            canvas (tk.Canvas): Родительский канвас.
            color (Tuple[int, int, int]): Цвет для генерации заднего фона.
            back_ground (Any): Объект заднего фона.
            anchor (str): Точка привязки.
            x (int): X-координата.
            y (int): Y-координата.
            figure (Any): Изображение для слайдера.
            visual (ButtonVisual): Визуальное поведение.
            selected_func (Callable): Функция обработки нажатия.
        """
        slider_canvas = tk.Canvas(canvas, width=self.width, height=self.height, background=color,
                                  highlightthicknes=0)
        slider_canvas.back_ground, slider_canvas.overlap_figure = slider_background(color, back_ground)
        self.back_ground = slider_canvas.create_image(self.width // 2, self.height // 2,
                                                      image=slider_canvas.back_ground, anchor="center")
        slider_canvas.create_image(0, 0, image=slider_canvas.overlap_figure, anchor="nw")

        # Размещаем канвас слайдера в указанной позиции
        slider_canvas.place(x=x, y=y, anchor=anchor)

        return slider_canvas, self.width // 2, self.height // 2, figure, visual, selected_func

    def on_drag(self, event: tk.Event) -> None:
        """
        Обработчик перетаскивания слайдера.
        Обновляет позицию слайдера в зависимости от положения курсора.

        Args:
            event (tk.Event): Событие движения мыши.
        """
        current_pos = event.x
        self.position = min(max(current_pos, self.min_pos), self.max_pos)
        self.update_slider_position()

    def update_slider_position(self) -> None:
        """
        Обновляет координаты движущегося элемента слайдера и его заднего фона.
        """
        self.canvas.coords(self.figure, self.position, self.canvas.coords(self.figure)[1])
        self.canvas.coords(self.back_ground, self.position, self.canvas.coords(self.back_ground)[1])

    def unpush_logic(self, event: tk.Event) -> None:
        """
        Обработчик отпускания слайдера.
        Вызывает логику слайдера с текущим значением и обновляет визуальное состояние.
        """
        if self.visual.is_available:
            self.selected_func((self.position - self.min_pos) / self.slider_range)
        self.visual.handler(self.canvas, self.figure, "<ButtonRelease-1>")