main.py

import tkinter as tk
import os
import tempfile
from pathlib import Path
from typing import Tuple, List
from tkinter import ttk, messagebox, filedialog
from PIL import Image, ImageTk
from johnson_algorithm import (
    Graph,
    johnson_algorithm,
    parse_adjacency_matrix,
    format_result_matrix,
    find_shortest_paths_info,
    visualize_graph,
)


class JohnsonAlgorithmApp:
    """
    Главное приложение для алгоритма Джонсона.

    Предоставляет графический интерфейс для:
    - Ввода матрицы смежности графа
    - Выполнения алгоритма Джонсона
    - Визуализации графа
    - Отображения результатов поиска кратчайших путей

    Attributes:
        root: Корневое окно Tkinter
        current_graph: Текущий граф для визуализации
        temp_image_files: Список временных файлов изображений для очистки
    """

    # Константы для размеров окна
    WINDOW_WIDTH = 800
    WINDOW_HEIGHT = 600
    MIN_WIDTH = 600
    MIN_HEIGHT = 400

    # Константы для шрифтов
    FONT_DEFAULT = ("Arial", 12, "bold")
    FONT_MONOSPACE = ("Consolas", 10)
    FONT_INSTRUCTION = ("Arial", 9)
    FONT_CANVAS_TEXT = ("Arial", 12)

    # Константы для Canvas
    CANVAS_TEXT_X = 400
    CANVAS_TEXT_Y = 200

    # Примеры графов
    EXAMPLES = {
        1: {
            "name": "Пример 1 (4 вершины)",
            "description": "Загружен пример 1",
            "matrix": """0 1 3 inf
inf 0 1 2
inf inf 0 1
inf inf inf 0""",
        },
        2: {
            "name": "Пример 2 (5 вершин)",
            "description": "Загружен пример 2",
            "matrix": """0 4 2 inf inf
inf 0 1 5 inf
inf inf 0 8 3
inf inf inf 0 inf
inf inf inf 2 0""",
        },
        3: {
            "name": "Пример 3 (отриц. веса)",
            "description": "Загружен пример 3 (с отрицательными весами)",
            "matrix": """0 3 8 inf -4
inf 0 inf 1 7
inf 4 0 inf inf
2 inf -5 0 inf
inf inf inf 6 0""",
        },
    }

    def __init__(self, root: tk.Tk) -> None:
        """
        Инициализация приложения.

        Args:
            root: Корневое окно Tkinter для приложения
        """
        self.root = root
        self.root.title("Johnson Algorithm GUI")
        self.root.geometry(f"{self.WINDOW_WIDTH}x{self.WINDOW_HEIGHT}")
        self.root.minsize(self.MIN_WIDTH, self.MIN_HEIGHT)

        # Настройка обработчика закрытия окна для очистки временных файлов
        self.root.protocol("WM_DELETE_WINDOW", self.on_closing)

        # Настройка стиля
        self.setup_styles()

        # Создание интерфейса
        self.create_menu()
        self.create_toolbar()
        self.create_main_content()
        self.create_statusbar()

    def setup_styles(self) -> None:
        """Настройка стилей для виджетов"""
        style = ttk.Style()
        style.theme_use("clam")

    def create_menu(self) -> None:
        """Создание меню приложения"""
        menubar = tk.Menu(self.root)
        self.root.config(menu=menubar)

        # Меню "Файл"
        file_menu = tk.Menu(menubar, tearoff=0)
        menubar.add_cascade(label="Файл", menu=file_menu)
        file_menu.add_command(
            label="Открыть...", command=self.open_file, accelerator="Ctrl+O"
        )
        file_menu.add_command(
            label="Сохранить", command=self.save_file, accelerator="Ctrl+S"
        )
        file_menu.add_separator()
        file_menu.add_command(label="Выход", command=self.quit_app)

        # Меню "Правка"
        edit_menu = tk.Menu(menubar, tearoff=0)
        menubar.add_cascade(label="Правка", menu=edit_menu)
        edit_menu.add_command(label="Очистить", command=self.clear_data)

        # Меню "Алгоритм"
        algorithm_menu = tk.Menu(menubar, tearoff=0)
        menubar.add_cascade(label="Алгоритм", menu=algorithm_menu)
        algorithm_menu.add_command(
            label="Запустить", command=self.run_algorithm, accelerator="F5"
        )

        # Меню "Справка"
        help_menu = tk.Menu(menubar, tearoff=0)
        menubar.add_cascade(label="Справка", menu=help_menu)
        help_menu.add_command(label="О программе", command=self.show_about)

        # Горячие клавиши
        self.root.bind("<Control-o>", lambda e: self.open_file())
        self.root.bind("<Control-s>", lambda e: self.save_file())
        self.root.bind("<F5>", lambda e: self.run_algorithm())

    def create_toolbar(self) -> None:
        """Создание панели инструментов"""
        toolbar = ttk.Frame(self.root)
        toolbar.pack(side=tk.TOP, fill=tk.X, padx=2, pady=2)

        # Кнопки на панели инструментов
        ttk.Button(toolbar, text="Открыть", command=self.open_file).pack(
            side=tk.LEFT, padx=2
        )
        ttk.Button(toolbar, text="Сохранить", command=self.save_file).pack(
            side=tk.LEFT, padx=2
        )
        ttk.Separator(toolbar, orient=tk.VERTICAL).pack(side=tk.LEFT, fill=tk.Y, padx=5)
        ttk.Button(toolbar, text="Запустить алгоритм", command=self.run_algorithm).pack(
            side=tk.LEFT, padx=2
        )
        ttk.Separator(toolbar, orient=tk.VERTICAL).pack(side=tk.LEFT, fill=tk.Y, padx=5)
        ttk.Button(toolbar, text="Очистить", command=self.clear_data).pack(
            side=tk.LEFT, padx=2
        )

    def create_main_content(self) -> None:
        """Создание основного контента"""
        # Создание notebook для вкладок
        self.notebook = ttk.Notebook(self.root)
        self.notebook.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)

        # Вкладка "Ввод данных"
        self.input_frame = ttk.Frame(self.notebook)
        self.notebook.add(self.input_frame, text="Ввод данных")
        self.create_input_tab()

        # Вкладка "Результаты"
        self.result_frame = ttk.Frame(self.notebook)
        self.notebook.add(self.result_frame, text="Результаты")
        self.create_result_tab()

        # Вкладка "Визуализация"
        self.visualization_frame = ttk.Frame(self.notebook)
        self.notebook.add(self.visualization_frame, text="Визуализация")
        self.create_visualization_tab()

        # Хранение текущего графа для визуализации
        self.current_graph = None
        self.temp_image_files = []  # Список временных файлов для очистки

    def create_input_tab(self) -> None:
        """Создание вкладки для ввода данных"""
        # Левая панель для ввода
        left_panel = ttk.Frame(self.input_frame)
        left_panel.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=5, pady=5)

        ttk.Label(left_panel, text="Ввод данных:", font=self.FONT_DEFAULT).pack(
            anchor=tk.W
        )

        # Область для ввода данных
        input_text_frame = ttk.Frame(left_panel)
        input_text_frame.pack(fill=tk.BOTH, expand=True, pady=5)

        self.input_text = tk.Text(
            input_text_frame, wrap=tk.WORD, font=self.FONT_MONOSPACE
        )
        scrollbar_input = ttk.Scrollbar(
            input_text_frame, orient=tk.VERTICAL, command=self.input_text.yview
        )
        self.input_text.config(yscrollcommand=scrollbar_input.set)

        self.input_text.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        scrollbar_input.pack(side=tk.RIGHT, fill=tk.Y)

        # Правая панель для настроек и примера
        right_panel = ttk.LabelFrame(self.input_frame, text="Настройки и примеры")
        right_panel.pack(side=tk.RIGHT, fill=tk.BOTH, padx=5, pady=5)

        # Инструкция
        instruction_frame = ttk.LabelFrame(right_panel, text="Формат ввода")
        instruction_frame.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)

        instruction_text = (
            "Введите матрицу смежности:\n"
            "• Числа разделены пробелами\n"
            "• Строки разделены переносами\n"
            "• 'inf' = нет ребра\n"
            "• 0 = ребро с весом 0 (включая петли)\n"
            "• Другие числа = вес ребра\n\n"
            "Пример:\n"
            "0 1 3 inf\n"
            "inf 0 1 2\n"
            "inf inf 0 1\n"
            "inf inf inf 0"
        )

        # Используем Text виджет для корректного отображения всего текста
        # Получаем цвет фона для соответствия стилю ttk
        style = ttk.Style()
        bg_color = style.lookup("TLabelFrame", "background")
        if not bg_color:
            bg_color = self.root.cget("bg")

        instruction_text_widget = tk.Text(
            instruction_frame,
            wrap=tk.WORD,
            font=self.FONT_INSTRUCTION,
            height=12,
            state=tk.DISABLED,
            relief=tk.FLAT,
            bg=bg_color,
            borderwidth=0,
            highlightthickness=0,
        )
        instruction_text_widget.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
        instruction_text_widget.config(state=tk.NORMAL)
        instruction_text_widget.insert(1.0, instruction_text)
        instruction_text_widget.config(state=tk.DISABLED)

        # Кнопки примеров
        examples_frame = ttk.LabelFrame(right_panel, text="Примеры")
        examples_frame.pack(fill=tk.X, padx=5, pady=5)

        for example_id, example_data in self.EXAMPLES.items():
            ttk.Button(
                examples_frame,
                text=example_data["name"],
                command=lambda eid=example_id: self.load_example(eid),
            ).pack(fill=tk.X, padx=5, pady=2)

        # Кнопка очистки
        ttk.Button(
            right_panel, text="Очистить поле ввода", command=self.clear_input
        ).pack(fill=tk.X, padx=5, pady=5)

    def create_result_tab(self) -> None:
        """Создание вкладки для результатов"""
        # Область для вывода результатов
        result_text_frame = ttk.Frame(self.result_frame)
        result_text_frame.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)

        ttk.Label(
            result_text_frame,
            text="Результаты выполнения алгоритма:",
            font=self.FONT_DEFAULT,
        ).pack(anchor=tk.W, pady=5)

        self.result_text = tk.Text(
            result_text_frame, wrap=tk.WORD, font=self.FONT_MONOSPACE, state=tk.DISABLED
        )
        scrollbar_result = ttk.Scrollbar(
            result_text_frame, orient=tk.VERTICAL, command=self.result_text.yview
        )
        self.result_text.config(yscrollcommand=scrollbar_result.set)

        self.result_text.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        scrollbar_result.pack(side=tk.RIGHT, fill=tk.Y)

    def create_visualization_tab(self) -> None:
        """Создание вкладки для визуализации графа"""
        # Заголовок
        header_frame = ttk.Frame(self.visualization_frame)
        header_frame.pack(fill=tk.X, padx=5, pady=5)

        ttk.Label(
            header_frame,
            text="Визуализация графа:",
            font=self.FONT_DEFAULT,
        ).pack(side=tk.LEFT)

        # Кнопка обновления визуализации
        ttk.Button(
            header_frame,
            text="Обновить визуализацию",
            command=self.update_visualization,
        ).pack(side=tk.RIGHT, padx=5)

        # Фрейм для Canvas с прокруткой
        canvas_frame = ttk.Frame(self.visualization_frame)
        canvas_frame.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)

        # Canvas для отображения изображения
        self.visualization_canvas = tk.Canvas(
            canvas_frame, bg="white", highlightthickness=1, highlightbackground="gray"
        )

        # Вертикальная прокрутка
        v_scrollbar = ttk.Scrollbar(
            canvas_frame, orient=tk.VERTICAL, command=self.visualization_canvas.yview
        )
        self.visualization_canvas.configure(yscrollcommand=v_scrollbar.set)

        # Горизонтальная прокрутка
        h_scrollbar = ttk.Scrollbar(
            canvas_frame, orient=tk.HORIZONTAL, command=self.visualization_canvas.xview
        )
        self.visualization_canvas.configure(xscrollcommand=h_scrollbar.set)

        # Размещение виджетов
        self.visualization_canvas.grid(row=0, column=0, sticky="nsew")
        v_scrollbar.grid(row=0, column=1, sticky="ns")
        h_scrollbar.grid(row=1, column=0, sticky="ew")

        canvas_frame.grid_rowconfigure(0, weight=1)
        canvas_frame.grid_columnconfigure(0, weight=1)

        # Хранение ссылок на изображение (чтобы не удалялось сборщиком мусора)
        self.visualization_image = None
        self.visualization_photo = None
        self.visualization_image_path = None

        # Начальное сообщение
        self.visualization_canvas.create_text(
            self.CANVAS_TEXT_X,
            self.CANVAS_TEXT_Y,
            text="Введите матрицу смежности и нажмите 'Визуализировать граф'\nили 'Запустить алгоритм' для отображения графа",
            font=self.FONT_CANVAS_TEXT,
            fill="gray",
            justify=tk.CENTER,
        )

    def display_graph_image(self, image_path: str) -> None:
        """
        Отображение изображения графа в Canvas.

        Автоматически масштабирует изображение, если оно больше Canvas.
        Обрабатывает различные расширения файлов (.png, .PNG).

        Args:
            image_path: Путь к файлу изображения графа

        Raises:
            FileNotFoundError: Если файл изображения не найден
        """
        try:
            # Проверка существования файла
            if not os.path.exists(image_path):
                # Graphviz может создать файл с другим расширением
                # Пробуем найти файл без расширения или с другим расширением
                base_path = os.path.splitext(image_path)[0]
                possible_paths = [
                    image_path,
                    base_path + ".png",
                    base_path + ".PNG",
                ]

                found_path = None
                for path in possible_paths:
                    if os.path.exists(path):
                        found_path = path
                        break

                if found_path is None:
                    raise FileNotFoundError(
                        f"Файл изображения не найден: {image_path}\n"
                        f"Проверено: {', '.join(possible_paths)}"
                    )

                image_path = found_path

            # Загрузка изображения
            self.visualization_image = Image.open(image_path)
            self.visualization_image_path = image_path
            img = self.visualization_image

            # Очистка Canvas
            self.visualization_canvas.delete("all")

            # Обновление Canvas для получения актуальных размеров
            self.visualization_canvas.update_idletasks()

            # Получение размеров Canvas
            canvas_width = self.visualization_canvas.winfo_width()
            canvas_height = self.visualization_canvas.winfo_height()

            # Если Canvas еще не отрисован, используем размеры изображения
            if canvas_width <= 1:
                canvas_width = img.width
            if canvas_height <= 1:
                canvas_height = img.height

            # Масштабирование изображения, если оно больше Canvas
            img_width, img_height = img.size
            scale = min(
                canvas_width / img_width if img_width > 0 else 1,
                canvas_height / img_height if img_height > 0 else 1,
                1.0,  # Не увеличиваем изображение
            )

            if scale < 1.0:
                new_width = int(img_width * scale)
                new_height = int(img_height * scale)
                img = img.resize((new_width, new_height), Image.Resampling.LANCZOS)

            # Создание PhotoImage (сохраняем ссылку в атрибуте класса)
            self.visualization_photo = ImageTk.PhotoImage(img)

            # Отображение изображения по центру
            x = canvas_width // 2
            y = canvas_height // 2
            self.visualization_canvas.create_image(
                x, y, image=self.visualization_photo, anchor=tk.CENTER
            )

            # Обновление области прокрутки (используем размеры изображения)
            self.visualization_canvas.configure(
                scrollregion=(
                    0,
                    0,
                    max(canvas_width, img.width),
                    max(canvas_height, img.height),
                )
            )

            self.update_status("Визуализация обновлена")
        except Exception as e:
            self.visualization_canvas.delete("all")
            self.visualization_canvas.create_text(
                self.CANVAS_TEXT_X,
                self.CANVAS_TEXT_Y,
                text=f"Ошибка загрузки изображения:\n{str(e)}",
                font=self.FONT_CANVAS_TEXT,
                fill="red",
                justify=tk.CENTER,
            )
            self.update_status("Ошибка при отображении визуализации")

    def update_visualization(self) -> None:
        """Обновление визуализации текущего графа"""
        if self.current_graph is None:
            messagebox.showwarning(
                "Предупреждение",
                "Нет данных для визуализации.\nВведите матрицу смежности и запустите алгоритм.",
            )
            return

        try:
            self.update_status("Создание визуализации...")

            # Создание временного файла для визуализации
            # Graphviz добавляет расширение сам, поэтому создаем имя без расширения
            temp_dir = tempfile.gettempdir()
            temp_fd, temp_path = tempfile.mkstemp(
                suffix="", prefix="graphviz_", dir=temp_dir
            )
            os.close(temp_fd)  # Закрываем файловый дескриптор, файл не нужен
            os.remove(temp_path)  # Удаляем пустой файл, Graphviz создаст свой

            # Визуализация графа (Graphviz добавит .png сам)
            visualize_graph(self.current_graph, output_file=temp_path, format="png")

            # Graphviz создает файл с расширением, добавляем его к пути
            actual_path = temp_path + ".png"
            if not os.path.exists(actual_path):
                raise FileNotFoundError(
                    f"Файл визуализации не был создан: {actual_path}"
                )
            temp_path = actual_path

            # Сохранение пути к временному файлу
            self.temp_image_files.append(temp_path)

            # Отображение в GUI
            self.display_graph_image(temp_path)

            # Переключение на вкладку визуализации
            self.notebook.select(self.visualization_frame)

        except Exception as e:
            error_msg = str(e)
            if "graphviz" in error_msg.lower() or "executable" in error_msg.lower():
                error_msg = (
                    "Не удалось найти исполняемый файл Graphviz.\n\n"
                    "Для работы визуализации необходимо установить Graphviz:\n"
                    "https://graphviz.org/download/\n\n"
                    f"Ошибка: {error_msg}"
                )
            messagebox.showerror(
                "Ошибка", f"Не удалось создать визуализацию:\n{error_msg}"
            )
            self.update_status("Ошибка при визуализации")

    def _cleanup_temp_file(self, filepath: str) -> None:
        """Удаление временного файла"""
        try:
            if os.path.exists(filepath):
                os.remove(filepath)
        except Exception:
            pass  # Игнорируем ошибки при удалении

    def create_statusbar(self) -> None:
        """Создание строки состояния"""
        self.statusbar = ttk.Label(
            self.root, text="Готов", relief=tk.SUNKEN, anchor=tk.W
        )
        self.statusbar.pack(side=tk.BOTTOM, fill=tk.X)

    def update_status(self, message: str) -> None:
        """Обновление строки состояния"""
        self.statusbar.config(text=message)
        self.root.update_idletasks()

    def open_file(self) -> None:
        """
        Открытие файла с матрицей смежности.

        Поддерживает форматы: .txt и все файлы.
        Выполняет валидацию пути, прав доступа и размера файла (макс. 10 МБ).
        """
        filename = filedialog.askopenfilename(
            title="Открыть файл",
            filetypes=[("Текстовые файлы", "*.txt"), ("Все файлы", "*.*")],
        )
        if not filename:
            return

        # Валидация пути
        try:
            file_path = Path(filename)
            if not file_path.exists():
                messagebox.showerror("Ошибка", f"Файл не существует: {filename}")
                return
            if not file_path.is_file():
                messagebox.showerror(
                    "Ошибка", f"Указанный путь не является файлом: {filename}"
                )
                return
            if not os.access(filename, os.R_OK):
                messagebox.showerror("Ошибка", f"Нет прав на чтение файла: {filename}")
                return

            # Проверка размера файла (ограничение 10 МБ)
            file_size = file_path.stat().st_size
            max_size = 10 * 1024 * 1024  # 10 МБ
            if file_size > max_size:
                messagebox.showerror(
                    "Ошибка",
                    f"Файл слишком большой ({file_size / 1024 / 1024:.2f} МБ). "
                    f"Максимальный размер: {max_size / 1024 / 1024} МБ",
                )
                return

            with open(filename, "r", encoding="utf-8") as f:
                content = f.read()
                self.input_text.delete(1.0, tk.END)
                self.input_text.insert(1.0, content)
            self.update_status(f"Файл открыт: {filename}")
        except PermissionError:
            messagebox.showerror("Ошибка", f"Нет прав на чтение файла: {filename}")
        except UnicodeDecodeError:
            messagebox.showerror(
                "Ошибка",
                "Не удалось декодировать файл. Убедитесь, что файл в кодировке UTF-8.",
            )
        except Exception as e:
            messagebox.showerror("Ошибка", f"Не удалось открыть файл:\n{str(e)}")

    def save_file(self) -> None:
        """
        Сохранение текущей матрицы смежности в файл.

        Выполняет валидацию пути и прав на запись.
        По умолчанию сохраняет в формате .txt.
        """
        filename = filedialog.asksaveasfilename(
            title="Сохранить файл",
            defaultextension=".txt",
            filetypes=[("Текстовые файлы", "*.txt"), ("Все файлы", "*.*")],
        )
        if not filename:
            return

        # Валидация пути
        try:
            file_path = Path(filename)
            parent_dir = file_path.parent

            # Проверка существования родительской директории
            if not parent_dir.exists():
                messagebox.showerror(
                    "Ошибка", f"Директория не существует: {parent_dir}"
                )
                return

            # Проверка прав на запись
            if not os.access(str(parent_dir), os.W_OK):
                messagebox.showerror(
                    "Ошибка", f"Нет прав на запись в директорию: {parent_dir}"
                )
                return

            # Если файл существует, проверяем права на запись
            if file_path.exists() and not os.access(filename, os.W_OK):
                messagebox.showerror("Ошибка", f"Нет прав на запись в файл: {filename}")
                return

            content = self.input_text.get(1.0, tk.END)
            with open(filename, "w", encoding="utf-8") as f:
                f.write(content)
            self.update_status(f"Файл сохранен: {filename}")
        except PermissionError:
            messagebox.showerror("Ошибка", f"Нет прав на запись в файл: {filename}")
        except OSError as e:
            messagebox.showerror("Ошибка", f"Ошибка файловой системы:\n{str(e)}")
        except Exception as e:
            messagebox.showerror("Ошибка", f"Не удалось сохранить файл:\n{str(e)}")

    def clear_data(self) -> None:
        """Очистка данных"""
        if messagebox.askyesno("Подтверждение", "Очистить все данные?"):
            self.input_text.delete(1.0, tk.END)
            self.result_text.config(state=tk.NORMAL)
            self.result_text.delete(1.0, tk.END)
            self.result_text.config(state=tk.DISABLED)

            # Очистка визуализации
            self.current_graph = None
            self.visualization_canvas.delete("all")
            self.visualization_canvas.create_text(
                self.CANVAS_TEXT_X,
                self.CANVAS_TEXT_Y,
                text="Введите матрицу смежности и нажмите 'Визуализировать граф'\nили 'Запустить алгоритм' для отображения графа",
                font=self.FONT_CANVAS_TEXT,
                fill="gray",
                justify=tk.CENTER,
            )

            self.update_status("Данные очищены")

    def clear_input(self) -> None:
        """Очистка только поля ввода"""
        self.input_text.delete(1.0, tk.END)
        self.update_status("Поле ввода очищено")

    def load_example(self, example_id: int) -> None:
        """
        Загрузка предустановленного примера графа.

        Args:
            example_id: Идентификатор примера (1, 2 или 3)

        Raises:
            Показывает сообщение об ошибке, если пример не найден
        """
        if example_id not in self.EXAMPLES:
            messagebox.showerror("Ошибка", f"Пример {example_id} не найден")
            return

        example_data = self.EXAMPLES[example_id]
        self.input_text.delete(1.0, tk.END)
        self.input_text.insert(1.0, example_data["matrix"])
        self.update_status(example_data["description"])

    def _parse_input_matrix(self) -> Tuple[int, List[List[float]]]:
        """Парсинг матрицы смежности из поля ввода"""
        input_data = self.input_text.get(1.0, tk.END).strip()
        if not input_data:
            raise ValueError("Введите матрицу смежности!")
        return parse_adjacency_matrix(input_data)

    def _display_error_result(
        self, error_message: str, error_type: str = "ОШИБКА"
    ) -> None:
        """Отображение ошибки в результатах"""
        self.result_text.config(state=tk.NORMAL)
        self.result_text.delete(1.0, tk.END)
        self.result_text.insert(1.0, f"{error_type}: {error_message}\n\n")

        if "отрицательный цикл" in error_message.lower():
            self.result_text.insert(
                tk.END,
                "Алгоритм Джонсона не может быть выполнен, так как в графе обнаружен отрицательный цикл.\n"
                "Отрицательные циклы делают задачу поиска кратчайших путей неразрешимой.",
            )
        elif error_type == "ОШИБКА ПАРСИНГА":
            self.result_text.insert(
                tk.END,
                "Проверьте формат ввода матрицы смежности.\n"
                "Убедитесь, что:\n"
                "• Матрица квадратная\n"
                "• Все значения числовые или 'inf'\n"
                "• Строки разделены переносами строк",
            )
        else:
            self.result_text.insert(
                tk.END, f"Тип ошибки: {type(error_message).__name__}"
            )

        self.result_text.config(state=tk.DISABLED)

    def _display_success_result(self, result_matrix: List[List[float]]) -> None:
        """Отображение успешных результатов"""
        result_text = format_result_matrix(result_matrix)
        result_text += find_shortest_paths_info(result_matrix)

        self.result_text.config(state=tk.NORMAL)
        self.result_text.delete(1.0, tk.END)
        self.result_text.insert(1.0, result_text)
        self.result_text.config(state=tk.DISABLED)

        messagebox.showinfo(
            "Успех",
            "Алгоритм успешно выполнен!\n"
            "Найдены кратчайшие пути между всеми парами вершин.",
        )

    def run_algorithm(self) -> None:
        """Запуск алгоритма Джонсона"""
        self.update_status("Выполнение алгоритма...")

        try:
            # Парсинг и создание графа
            num_vertices, matrix = self._parse_input_matrix()
            graph = Graph(num_vertices)
            graph.from_adjacency_matrix(matrix)
            self.current_graph = graph

            # Выполнение алгоритма Джонсона
            success, result_matrix, error_message = johnson_algorithm(graph)

            if not success:
                self._display_error_result(error_message)
                messagebox.showerror("Ошибка", error_message)
                self.update_status("Ошибка: обнаружен отрицательный цикл")
            else:
                self._display_success_result(result_matrix)
                # Автоматическое обновление визуализации
                self.update_visualization()
                self.update_status("Алгоритм выполнен успешно")

        except ValueError as e:
            self._display_error_result(str(e), "ОШИБКА ПАРСИНГА")
            messagebox.showerror("Ошибка ввода", str(e))
            self.update_status("Ошибка при выполнении")

        except Exception as e:
            self._display_error_result(str(e), "НЕПРЕДВИДЕННАЯ ОШИБКА")
            messagebox.showerror("Ошибка", f"Произошла ошибка:\n{str(e)}")
            self.update_status("Ошибка при выполнении")

    def show_about(self) -> None:
        """Показ информации о программе"""
        messagebox.showinfo(
            "О программе",
            "Johnson Algorithm GUI\n\n"
            "Приложение для поиска кратчайших путей\n"
            "между всеми парами вершин в графе\n"
            "с использованием алгоритма Джонсона.\n\n"
            "Алгоритм работает с графами, содержащими\n"
            "отрицательные веса ребер (но без отрицательных циклов).\n\n"
            "Версия: 0.1.0",
        )

    def on_closing(self) -> None:
        """Обработчик закрытия окна (через крестик)"""
        # Очистка временных файлов и выход без подтверждения
        self._cleanup_all_temp_files()
        self.root.quit()
        self.root.destroy()

    def quit_app(self) -> None:
        """Выход из приложения (через меню)"""
        # Спрашиваем подтверждение при выходе через меню
        if messagebox.askyesno("Выход", "Вы уверены, что хотите выйти?"):
            # Очистка временных файлов
            self._cleanup_all_temp_files()
            self.root.quit()
            self.root.destroy()

    def _cleanup_all_temp_files(self) -> None:
        """Очистка всех временных файлов"""
        for temp_file in self.temp_image_files:
            self._cleanup_temp_file(temp_file)
        self.temp_image_files.clear()


def main():
    """Главная функция приложения"""
    # Добавление локального Graphviz в PATH, если он существует
    local_graphviz_path = os.path.join(os.getcwd(), "Graphviz-14.1.1-win64", "bin")
    if os.path.exists(local_graphviz_path):
        os.environ["PATH"] += os.pathsep + local_graphviz_path

    root = tk.Tk()
    JohnsonAlgorithmApp(root)
    root.mainloop()


if __name__ == "__main__":
    main()