Удали кнопку понятно import sys
import sqlite3
import random

from PyQt6.QtWidgets import (
    QApplication, QWidget, QLabel, QPushButton,
    QVBoxLayout, QHBoxLayout, QMessageBox,
    QLineEdit, QSizePolicy, QScrollArea
)
from PyQt6.QtCore import Qt, pyqtSignal


# Подключение к базе данных
# Убедитесь, что файл базы данных 'justproject.db' существует или будет создан автоматически
try:
    conn = sqlite3.connect('justproject')  # Используйте правильное расширение файла (.db)
    cur = conn.cursor()
except sqlite3.Error as e:
    print(f"Не удалось подключиться к базе данных: {e}")
    sys.exit(1)


class MainWindow(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Тестирование по русскому языку (ЕГЭ)")
        self.resize(400, 200)  # Настройка размера окна

        # Кнопки выбора заданий
        button_udarenie = QPushButton("Ударение (№4 ЕГЭ)")
        button_udarenie.clicked.connect(self.open_udarenie_window)
        button_poliformizmy = QPushButton("Полиморфизмы (№5 ЕГЭ)")
        button_poliformizmy.clicked.connect(self.open_poliformizmy_window)

        # Размещение кнопок горизонтально
        hbox = QHBoxLayout()
        hbox.addWidget(button_udarenie)
        hbox.addWidget(button_poliformizmy)

        # Размещение элементов вертикально
        vbox = QVBoxLayout()
        vbox.addLayout(hbox)
        self.setLayout(vbox)

        # Хранение окон для предотвращения сборки мусора
        self.udarenie_window = None
        self.poliformizmy_window = None

    def open_udarenie_window(self):
        self.udarenie_window = UdarenieWindow(cur)
        self.udarenie_window.show()

    def open_poliformizmy_window(self):
        self.poliformizmy_window = PoliformizmyWindow()
        self.poliformizmy_window.show()


class UdarenieWindow(QWidget):
    def __init__(self, cursor):
        super().__init__()
        self.setWindowTitle("Результаты: Ударение")
        self.resize(400, 200)  # Настройка размера окна

        # Текст с результатом
        self.result_label = QLabel("Твой результат: [процент правильных ответов]")
        self.result_label.setAlignment(Qt.AlignmentFlag.AlignCenter)

        # Кнопка "Начать тест"
        start_test_button = QPushButton("Начать тест")
        start_test_button.clicked.connect(self.open_udarenie2_window)

        # Размещение элементов
        vbox = QVBoxLayout()
        vbox.addWidget(self.result_label)
        vbox.addWidget(start_test_button)
        self.setLayout(vbox)

        self.cursor = cursor  # Сохраняем курсор для передачи дальше
        self.udarenie2_window = None

        # Инициализация метки результата (изначально не показываем)
        self.display_last_result()

    def open_udarenie2_window(self):
        self.udarenie2_window = Udarenie2Window(self.cursor)
        self.udarenie2_window.test_finished.connect(self.display_result)
        self.udarenie2_window.show()

    def display_result(self, percentage):
        """Обновляет метку с результатом."""
        self.result_label.setText(f"Твой результат: {percentage:.2f}% правильных ответов")


    def display_last_result(self):
        """Получает последний сохранённый результат и отображает его."""
        # Так как мы убрали таблицу UdarenieResults, этот метод можно убрать или адаптировать
        # В данном случае будем отображать только текущий результат (из сессии)
        self.result_label.setText("Твой результат: [процент правильных ответов]")


class PoliformizmyWindow(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Результаты: Полиморфизмы")
        self.resize(400, 200)  # Настройка размера окна
        
        # Текст с результатом
        self.result_label = QLabel("Твой результат: [процент правильных ответов]")
        self.result_label.setAlignment(Qt.AlignmentFlag.AlignCenter)

        # Кнопка "Продолжить"
        continue_button = QPushButton("Продолжить")
        continue_button.clicked.connect(self.open_poliformizmy2_window)

        # Размещение элементов
        vbox = QVBoxLayout()
        vbox.addWidget(self.result_label)
        vbox.addWidget(continue_button)
        self.setLayout(vbox)

        self.poliformizmy2_window = None

    def open_poliformizmy2_window(self):
        self.poliformizmy2_window = Poliformizmy2Window()
        self.poliformizmy2_window.show()


class Udarenie2Window(QWidget):
    # Определяем сигнал для передачи результата (процент правильных ответов)
    test_finished = pyqtSignal(float)

    def __init__(self, cursor):
        super().__init__()
        self.setWindowTitle("Тест по Ударению")
        self.resize(600, 400)  # Устанавливаем размер окна

        self.cur = cursor  # Передаём курсор базы данных в класс

        # Загрузка данных из базы данных
        self.load_data()

        # Инициализация текущего состояния
        self.current_word = 0
        self.correct_count = 0
        self.total_words = len(self.test_data)

        # Перемешивание слов для рандомизации порядка
        combined = list(zip(self.test_data, self.correct_answers))
        random.shuffle(combined)
        if combined:
            shuffled_test_data, shuffled_correct_answers = zip(*combined)
            self.test_data = list(shuffled_test_data)
            self.correct_answers = list(shuffled_correct_answers)
        else:
            self.test_data = []
            self.correct_answers = []

        # Инициализация и настройка виджетов
        self.init_ui()

        # Первоначальное отображение первого слова и кнопок
        self.update_word_label()
        self.create_letter_buttons()

    def load_data(self):
        """
        Загружает данные из базы данных.
        Ожидается, что таблица Udarenie содержит два столбца:
        - word (TEXT): Слово для теста
        - index_letter (INTEGER): Позиция ударной буквы (1-based индекс)
        """
        try:
            # Выполнение SQL-запроса для получения слов и индексов ударных букв
            data = self.cur.execute("SELECT word, index_letter FROM Udarenie").fetchall()
            self.test_data = [list(row[0]) for row in data]  # Список букв в каждом слове
            self.correct_answers = [row[1] for row in data]  # Индексы ударных букв
        except sqlite3.Error as e:
            QMessageBox.critical(
                self, "Ошибка базы данных",
                f"Не удалось загрузить данные из базы данных:\n{e}"
            )
            sys.exit(1)

        if not self.test_data:
            QMessageBox.information(
                self, "Нет данных",
                "В базе данных отсутствуют слова для тестирования."
            )
            sys.exit(0)  # Завершение программы, так как нет данных

    def init_ui(self):
        """Инициализирует и настраивает интерфейс пользователя."""
        # Метка для отображения текущего слова
        self.word_label = QLabel()
        self.word_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        self.word_label.setStyleSheet("font-size: 24px; font-weight: bold;")  # Настройка стиля (опционально)

        # Кнопка "Понятно"
        self.clearly_button = QPushButton("Понятно")
        self.clearly_button.clicked.connect(self.next_word)
        self.clearly_button.setVisible(False)  # Скрыта изначально
        self.clearly_button.setFixedWidth(100)  # Фиксированная ширина кнопки (опционально)

        # Кнопка "Посмотреть текущий результат"
        self.view_results_button = QPushButton("Посмотреть текущий результат")
        self.view_results_button.clicked.connect(self.view_results)

        # Кнопка "Выйти из теста"
        self.exit_button = QPushButton("Выйти из теста")
        self.exit_button.clicked.connect(self.exit_test)
        self.exit_button.setStyleSheet("background-color: red; color: white;")  # Стилизация кнопки выхода

        # Создание прокручиваемой области для кнопок букв
        self.scroll_area = QScrollArea()
        self.scroll_area.setWidgetResizable(True)
        self.scroll_area.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded)
        self.scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
        self.scroll_area.setFixedHeight(60)  # Установка фиксированной высоты прокручиваемой области

        # Внутренний виджет и горизонтальный макет для кнопок
        self.buttons_widget = QWidget()
        self.buttons_layout = QHBoxLayout()
        self.buttons_layout.setAlignment(Qt.AlignmentFlag.AlignCenter)
        self.buttons_widget.setLayout(self.buttons_layout)

        self.scroll_area.setWidget(self.buttons_widget)

        # Основной вертикальный макет
        main_layout = QVBoxLayout()
        main_layout.addWidget(self.word_label)
        main_layout.addWidget(self.scroll_area)  # Добавляем прокручиваемую область с кнопками
        main_layout.addWidget(self.clearly_button, alignment=Qt.AlignmentFlag.AlignCenter)
        main_layout.addWidget(self.view_results_button, alignment=Qt.AlignmentFlag.AlignCenter)  # Добавляем кнопку просмотра результатов
        main_layout.addWidget(self.exit_button, alignment=Qt.AlignmentFlag.AlignCenter)  # Добавляем кнопку выхода
        self.setLayout(main_layout)

    def update_word_label(self):
        """Обновляет текст метки с текущим словом."""
        if self.current_word < len(self.test_data):
            word = ''.join(self.test_data[self.current_word])
            self.word_label.setText(word)
        else:
            self.word_label.setText("Конец")  # Сообщение о завершении
            self.disable_buttons()  # Отключение кнопок при окончании

    def create_letter_buttons(self):
        """Создаёт кнопки для букв текущего слова в одном ряду."""
        # Очистка существующих кнопок из макета
        while self.buttons_layout.count():
            child = self.buttons_layout.takeAt(0)
            if child.widget():
                child.widget().deleteLater()

        self.letter_buttons = []
        try:
            current_letters = self.test_data[self.current_word]
        except IndexError:
            # Если текущий индекс выходит за пределы списка, ничего не делаем
            return

        for i, letter in enumerate(current_letters):
            button = QPushButton(letter)
            button.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Fixed)  # Фиксированный размер кнопки
            button.setFixedSize(40, 40)  # Установка фиксированного размера кнопки
            button.clicked.connect(lambda checked, i=i: self.check_answer(i))
            self.letter_buttons.append(button)
            self.buttons_layout.addWidget(button)

    def check_answer(self, index):
        """Проверяет, выбрал ли пользователь правильную букву."""
        if self.current_word >= len(self.correct_answers):
            return  # Предотвращает ошибки, если все слова пройдены

        correct_index = self.correct_answers[self.current_word] - 1  # Предполагается, что index_letter 1-based
        try:
            correct_letter = self.test_data[self.current_word][correct_index]
        except IndexError:
            QMessageBox.warning(
                self,
                "Ошибка",
                "Неправильный индекс правильной буквы."
            )
            self.clearly_button.setVisible(True)
            return

        if index == correct_index:
            QMessageBox.information(self, "Правильно!", "Молодец")
            self.correct_count += 1  # Увеличиваем счётчик правильных ответов
        else:
            QMessageBox.information(
                self,
                "Неправильно!",
                f"Правильный ответ: {correct_letter}"
            )
        self.clearly_button.setVisible(True)  # Показываем кнопку "Понятно"

    def next_word(self):
        """Переходит к следующему слову или завершает тест."""
        self.clearly_button.setVisible(False)  # Скрываем кнопку "Понятно" до следующего ответа
        self.current_word += 1
        if self.current_word < len(self.test_data):
            self.update_word_label()
            self.create_letter_buttons()
        else:
            # Тест завершён, вычисляем процент правильных ответов
            percentage = (self.correct_count / self.total_words) * 100 if self.total_words > 0 else 0
            # Эмитируем сигнал с процентом
            self.test_finished.emit(percentage)
            QMessageBox.information(self, "Закончили", "Все слова пройдены")
            self.disable_buttons()  # Отключение кнопок при окончании

    def view_results(self):
        """Показывает текущий результат без завершения теста."""
        if self.current_word == 0:
            percentage = 0
            message = "Ты ещё не дал ни одного ответа."
        else:
            percentage = (self.correct_count / self.current_word) * 100
            message = f"Твой текущий результат: {percentage:.2f}% правильных ответов ({self.correct_count} из {self.current_word})"

        QMessageBox.information(self, "Текущий результат", message)

    def exit_test(self):
        """Вычисляет текущий результат и закрывает тест."""
        if self.current_word == 0:
            percentage = 0
        else:
            percentage = (self.correct_count / self.current_word) * 100

        # Эмитируем сигнал с процентом
        self.test_finished.emit(percentage)

        QMessageBox.information(self, "Тест завершён", f"Ты завершил тест с результатом: {percentage:.2f}% правильных ответов")
        self.close()

    def disable_buttons(self):
        """Отключает все кнопки букв и скрывает кнопку 'Понятно'."""
        for button in self.letter_buttons:
            button.setEnabled(False)
        self.clearly_button.setVisible(False)

    def closeEvent(self, event):
        """Обработка закрытия окна для корректного завершения соединения с БД."""
        try:
            if hasattr(self, 'cur') and self.cur:
                self.cur.close()
            if hasattr(conn, 'close') and conn:
                conn.close()
        except:
            pass
        event.accept()


class Poliformizmy2Window(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Тест по Полиморфизмам")
        self.resize(600, 400)  # Настройка размера окна

        # БДшка (например, данные могут быть взяты из базы данных)
        self.test_data = [
            {
                "предложение": "Он был очень [умен/умный] и находчив.",
                "правильный_ответ": "умный",
                "пароним": "умен",
            },
            # Добавьте больше предложений по необходимости
        ]
        self.current_index = 0

        # Отображение предложения
        self.sentence_label = QLabel(self.test_data[self.current_index]["предложение"])
        self.sentence_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        self.sentence_label.setWordWrap(True)  # Разрешаем перенос строк

        # Кнопка "Ответить"
        self.incorrect_button = QPushButton("Ответить")
        self.incorrect_button.clicked.connect(self.prepare_input)

        # Поле для ввода слова
        self.input_field = QLineEdit()
        self.input_field.setPlaceholderText("Введите правильное слово")
        self.input_field.setVisible(False)

        # Кнопка "Проверить"
        self.check_button = QPushButton("Проверить")
        self.check_button.clicked.connect(self.check_input_answer)
        self.check_button.setVisible(False)

        # Кнопка "Понятно"
        self.clearly_button = QPushButton("Понятно")
        self.clearly_button.clicked.connect(self.next_sentence)
        self.clearly_button.setVisible(False)

        # Кнопка "Выйти из теста"
        self.exit_button = QPushButton("Выйти из теста")
        self.exit_button.clicked.connect(self.exit_test)
        self.exit_button.setStyleSheet("background-color: red; color: white;")  # Стилизация кнопки выхода

        # Размещение элементов
        vbox = QVBoxLayout()
        vbox.addWidget(self.sentence_label)
        vbox.addWidget(self.incorrect_button)
        vbox.addWidget(self.input_field)
        vbox.addWidget(self.check_button)
        vbox.addWidget(self.clearly_button)
        vbox.addWidget(self.exit_button)
        self.setLayout(vbox)

    def prepare_input(self):
        """Подготавливает интерфейс для ввода ответа."""
        self.incorrect_button.setVisible(False)
        self.input_field.setVisible(True)
        self.check_button.setVisible(True)

    def check_input_answer(self):
        """Проверяет ответ пользователя."""
        user_answer = self.input_field.text().strip().lower()
        correct_answer = self.test_data[self.current_index]["правильный_ответ"].lower()

        if not user_answer:
            QMessageBox.warning(self, "Внимание", "Пожалуйста, введите ответ перед проверкой.")
            return

        if user_answer == correct_answer:
            QMessageBox.information(self, "Правильно!", "Молодец")
        else:
            QMessageBox.information(
                self,
                "Неправильно!",
                f"Правильный ответ: {self.test_data[self.current_index]['правильный_ответ']}"
            )
        self.clearly_button.setVisible(True)  # Показываем кнопку "Понятно"

    def next_sentence(self):
        """Переходит к следующему предложению."""
        self.current_index += 1
        if self.current_index >= len(self.test_data):
            QMessageBox.information(self, "Закончили", "Все предложения пройдены")
            self.close()
            return

        # Обновляем текст
        self.sentence_label.setText(self.test_data[self.current_index]["предложение"])

        # Сбрасываем видимость элементов
        self.input_field.setText("")
        self.input_field.setVisible(False)
        self.check_button.setVisible(False)
        self.clearly_button.setVisible(False)
        self.incorrect_button.setVisible(True)

    def exit_test(self):
        """Закрывает тест после подтверждения пользователем."""
        reply = QMessageBox.question(
            self,
            'Выход из теста',
            "Вы действительно хотите выйти из теста? Текущий результат будет отображён.",
            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
            QMessageBox.StandardButton.No
        )

        if reply == QMessageBox.StandardButton.Yes:
            # Вычисляем текущий процент правильных ответов
            if self.current_word == 0:
                percentage = 0
            else:
                percentage = (self.correct_count / self.current_word) * 100

            QMessageBox.information(self, "Тест завершён", f"Ты завершил тест с результатом: {percentage:.2f}% правильных ответов")
            self.close()

    def disable_buttons(self):
        """Отключает все кнопки букв и скрывает кнопку 'Понятно'."""
        for button in self.letter_buttons:
            button.setEnabled(False)
        self.clearly_button.setVisible(False)

    def closeEvent(self, event):
        """Обработка закрытия окна для корректного завершения соединения с БД."""
        try:
            if hasattr(self, 'cur') and self.cur:
                self.cur.close()
            if hasattr(conn, 'close') and conn:
                conn.close()
        except:
            pass
        event.accept()


if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = MainWindow()
    window.show()
    app.aboutToQuit.connect(lambda: conn.close() if conn else None)
    sys.exit(app.exec())