ui.py

# ui.py
from __future__ import annotations

import os
from typing import List, Optional

from PyQt6.QtCore import QEvent, QTimer, Qt
from PyQt6.QtGui import QAction, QActionGroup, QKeySequence, QIcon
from PyQt6.QtWidgets import (
    QFrame,
    QHBoxLayout,
    QLabel,
    QMainWindow,
    QScrollArea,
    QVBoxLayout,
    QWidget,
    QApplication,
)

from i18n import I18N
from model import Project, load_autosave, save_autosave
from mainmenu import MainMenuBar
from toppanel import TopPanel
from bottompanel import BottomPanel
from readmode import ReadingModeController
from constants import CENTER_MAX_WIDTH, LINE_WIDTH, META_WIDTH
from block import BlockWidget, clear_layout, SyllableEdit
from file_operations import FileOperations
from panel_controller import PanelController
from block_navigation import BlockNavigator
from block_controller import BlockController
import logging

LOGGER = logging.getLogger(__name__)


class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()

        # Устанавливаем иконку окна
        icon_path = os.path.join(os.path.dirname(__file__), "img", "icon.png")
        if os.path.exists(icon_path):
            self.setWindowIcon(QIcon(icon_path))

        # Попробуем загрузить автосохранение
        autosaved_project = load_autosave()
        if autosaved_project:
            self.project: Project = autosaved_project
        else:
            self.project: Project = Project.new_default()
        self.i18n: I18N = I18N(self.project.lang)

        self.current_path: Optional[str] = None
        self.active_block_id: Optional[str] = self.project.blocks[0].id if self.project.blocks else None

        self.block_widgets: List[BlockWidget] = []
        self._building_ui: bool = False
        self._modified: bool = False
        self.file_ops = FileOperations(self)

        # Autosave: event-based + fallback timer (10s)
        self._autosave_timer = QTimer(self)
        self._autosave_timer.setSingleShot(True)
        self._autosave_timer.setInterval(10000)
        self._autosave_timer.timeout.connect(self._flush_autosave)

        self.reading_controller = ReadingModeController(enabled=False)
        self.reading_controller.modeChanged.connect(self._on_reading_mode_changed)

        self.panel_controller: Optional[PanelController] = None
        self.block_navigator: Optional[BlockNavigator] = None
        self.block_controller: BlockController = BlockController(self.project, self)

        self._init_actions()
        self._build_ui()

        # Подключаем кнопку режима чтения из top_panel
        self.top_panel.reading_btn.toggled.connect(self._on_toggle_reading_mode)

        self.panel_controller = PanelController(
            project_provider=lambda: self.project,
            top_panel=self.top_panel,
            reading_controller=self.reading_controller,
            block_widgets_provider=lambda: self.block_widgets,
            mark_modified=self.mark_modified,
            building_ui_flag=lambda: self._building_ui,
        )
        self._connect_top_panel_signals()

        self.block_navigator = BlockNavigator(
            project_provider=lambda: self.project,
            block_widgets_provider=lambda: self.block_widgets,
            nav_list=None,
            scroll_area=self.scroll,
            parent_widget=self,
            i18n=self.i18n,
            set_active_block=lambda bid: setattr(self, "active_block_id", bid),
            get_active_block=lambda: self.active_block_id,
            rebuild_all=self.rebuild_all,
            mark_modified=self.mark_modified,
            building_ui_flag=lambda: self._building_ui,
            navigation_updater=None,
            navigation_index_setter=None,
        )

        self._building_ui = True
        self.apply_language_to_ui()
        self.apply_project_to_controls()
        self._building_ui = False

        self.rebuild_all()
        self.mark_modified(False)
        self.statusBar().showMessage(self.i18n.t("READY"))

    @property
    def is_modified(self) -> bool:
        return self._modified

    @is_modified.setter
    def is_modified(self, value: bool) -> None:
        self._modified = value

    def _build_ui(self):
        self.setWindowTitle(self.i18n.t("APP_TITLE"))
        self.resize(1280, 820)

        self.reading_controller.apply_app_style()

        self.root_widget = QWidget()
        self.setCentralWidget(self.root_widget)
        self.root_layout = QVBoxLayout(self.root_widget)
        self.root_layout.setContentsMargins(0, 0, 0, 0)
        self.root_layout.setSpacing(0)

        self.menu_bar = MainMenuBar(self, self)
        self.root_layout.addWidget(self.menu_bar)

        # content row
        self.content_widget = QWidget()
        self.content_layout = QHBoxLayout(self.content_widget)
        self.content_layout.setContentsMargins(12, 48, 12, 12)
        self.content_layout.setSpacing(12)

        # center scroll (no horizontal scroll ever)
        self.scroll: QScrollArea = QScrollArea()
        self.scroll.setWidgetResizable(True)
        self.scroll.setFrameShape(QFrame.Shape.NoFrame)
        self.scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)

        center_host = QWidget()
        center_host_layout = QHBoxLayout(center_host)
        center_host_layout.setContentsMargins(0, 0, 0, 0)
        center_host_layout.setSpacing(0)

        center_host_layout.addStretch(1)

        self.canvas_container: QWidget = QWidget()
        self.canvas_container.setMaximumWidth(CENTER_MAX_WIDTH)
        # ВАЖНО: минимальная ширина центра, чтобы строка+информеры не “впихивались” и не наезжали
        self.canvas_container.setMinimumWidth(LINE_WIDTH + META_WIDTH + 80)

        self.canvas_layout: QVBoxLayout = QVBoxLayout(self.canvas_container)
        self.canvas_layout.setContentsMargins(0, 0, 0, 18)  # убрали верхний отступ
        self.canvas_layout.setSpacing(14)

        # Контейнер для блоков
        self.blocks_container: QWidget = QWidget(self.canvas_container)
        self.blocks_layout: QVBoxLayout = QVBoxLayout(self.blocks_container)
        self.blocks_layout.setContentsMargins(0, 0, 0, 0)
        self.blocks_layout.setSpacing(32)
        self.canvas_layout.addWidget(self.blocks_container)

        center_host_layout.addWidget(self.canvas_container)
        center_host_layout.addStretch(1)

        self.top_panel = TopPanel(self)
        self.root_layout.addWidget(self.top_panel)

        self.scroll.setWidget(center_host)
        self.content_layout.addWidget(self.scroll, 1)

        self.root_layout.addWidget(self.content_widget, 1)

        self.bottom_panel = BottomPanel(self)
        self.root_layout.addWidget(self.bottom_panel)

    # ---- actions ----
    def _init_actions(self):
        self.act_file_new = QAction(self)
        self.act_file_new.setShortcut(QKeySequence.StandardKey.New)
        self.act_file_new.triggered.connect(self.file_ops.file_new)
        self.addAction(self.act_file_new)

        self.act_file_open = QAction(self)
        self.act_file_open.setShortcut(QKeySequence.StandardKey.Open)
        self.act_file_open.triggered.connect(self.file_ops.file_open)
        self.addAction(self.act_file_open)

        self.act_file_save = QAction(self)
        self.act_file_save.setShortcut(QKeySequence.StandardKey.Save)
        self.act_file_save.triggered.connect(self.file_ops.file_save)
        self.addAction(self.act_file_save)

        self.act_file_import_txt = QAction(self)
        self.act_file_import_txt.triggered.connect(self.file_ops.file_import_txt)
        self.addAction(self.act_file_import_txt)

        self.act_file_export_txt = QAction(self)
        self.act_file_export_txt.setShortcut(QKeySequence(Qt.KeyboardModifier.ControlModifier | Qt.Key.Key_E))
        self.act_file_export_txt.triggered.connect(self.file_ops.file_export)
        self.addAction(self.act_file_export_txt)

        self.act_file_export_json = QAction(self)
        self.act_file_export_json.triggered.connect(self.file_ops.file_export_json)
        self.addAction(self.act_file_export_json)

        self._language_action_group = QActionGroup(self)
        self._language_action_group.setExclusive(True)

        self.act_language_english = QAction(self)
        self.act_language_english.setText(self.tr("English", "Language name (do not translate)"))
        self.act_language_english.setCheckable(True)
        self.act_language_english.triggered.connect(lambda: self._on_language_action("en"))
        self._language_action_group.addAction(self.act_language_english)

        self.act_language_russian = QAction(self)
        self.act_language_russian.setText(self.tr("Русский", "Language name (do not translate)"))
        self.act_language_russian.setCheckable(True)
        self.act_language_russian.triggered.connect(lambda: self._on_language_action("ru"))
        self._language_action_group.addAction(self.act_language_russian)

        self.act_insert_block = QAction(self)
        self.act_insert_block.setShortcut(QKeySequence(Qt.KeyboardModifier.ControlModifier | Qt.KeyboardModifier.ShiftModifier | Qt.Key.Key_N))
        self.act_insert_block.triggered.connect(self.insert_block_after_active)
        self.addAction(self.act_insert_block)

        self.act_insert_instr_block = QAction(self)
        self.act_insert_instr_block.setShortcut(QKeySequence(Qt.KeyboardModifier.ControlModifier | Qt.KeyboardModifier.ShiftModifier | Qt.Key.Key_I))
        self.act_insert_instr_block.triggered.connect(self.insert_instrumental_after_active)
        self.addAction(self.act_insert_instr_block)

        self.act_delete_block = QAction(self)
        self.act_delete_block.setShortcut(QKeySequence(Qt.KeyboardModifier.ControlModifier | Qt.Key.Key_Backspace))
        self.act_delete_block.triggered.connect(self.delete_active_block)
        self.addAction(self.act_delete_block)

        self.act_move_block_up = QAction(self)
        self.act_move_block_up.setShortcut(QKeySequence(Qt.KeyboardModifier.AltModifier | Qt.Key.Key_Up))
        self.act_move_block_up.triggered.connect(lambda: self.move_active_block(-1))
        self.addAction(self.act_move_block_up)

        self.act_move_block_down = QAction(self)
        self.act_move_block_down.setShortcut(QKeySequence(Qt.KeyboardModifier.AltModifier | Qt.Key.Key_Down))
        self.act_move_block_down.triggered.connect(lambda: self.move_active_block(1))
        self.addAction(self.act_move_block_down)

        self.act_edit_undo = QAction(self)
        self.act_edit_undo.triggered.connect(self._on_undo)
        self.addAction(self.act_edit_undo)

        self.act_edit_redo = QAction(self)
        self.act_edit_redo.triggered.connect(self._on_redo)
        self.addAction(self.act_edit_redo)

    # ---- i18n ----
    def apply_language_to_ui(self):
        self.setWindowTitle(self.i18n.t("APP_TITLE"))

        self.act_file_new.setText(self.i18n.t("NEW"))
        self.act_file_open.setText(self.i18n.t("OPEN"))
        self.act_file_save.setText(self.i18n.t("SAVE"))
        self.act_file_import_txt.setText(self.i18n.t("IMPORT_TXT"))
        self.act_file_export_txt.setText(self.i18n.t("EXPORT_TXT"))
        self.act_file_new.setToolTip(self.i18n.t("NEW_TIP"))
        self.act_file_open.setToolTip(self.i18n.t("OPEN_TIP"))
        self.act_file_save.setToolTip(self.i18n.t("SAVE_TIP"))
        self.act_file_import_txt.setToolTip(self.i18n.t("IMPORT_TXT_TIP"))
        self.act_file_export_txt.setToolTip(self.i18n.t("EXPORT_TXT_TIP"))
        self.act_file_new.setStatusTip(self.i18n.t("NEW_TIP"))
        self.act_file_open.setStatusTip(self.i18n.t("OPEN_TIP"))
        self.act_file_save.setStatusTip(self.i18n.t("SAVE_TIP"))
        self.act_file_import_txt.setStatusTip(self.i18n.t("IMPORT_TXT_TIP"))
        self.act_file_export_txt.setStatusTip(self.i18n.t("EXPORT_TXT_TIP"))
        self.act_language_english.setToolTip(self.i18n.t("LANGUAGE_ENGLISH_TIP"))
        self.act_language_russian.setToolTip(self.i18n.t("LANGUAGE_RUSSIAN_TIP"))
        self.act_language_english.setStatusTip(self.i18n.t("LANGUAGE_ENGLISH_TIP"))
        self.act_language_russian.setStatusTip(self.i18n.t("LANGUAGE_RUSSIAN_TIP"))
        self.act_insert_block.setText(self.i18n.t("INSERT_BLOCK"))
        self.act_insert_instr_block.setText(self.i18n.t("INSERT_INSTR_BLOCK"))
        self.act_delete_block.setText(self.i18n.t("DELETE_BLOCK"))
        self.act_move_block_up.setText(self.i18n.t("MOVE_BLOCK_UP"))
        self.act_move_block_down.setText(self.i18n.t("MOVE_BLOCK_DOWN"))
        self.act_insert_block.setToolTip(self.i18n.t("ADD_BLOCK_TIP"))
        self.act_insert_instr_block.setToolTip(self.i18n.t("ADD_INSTR_BLOCK_TIP"))
        self.act_delete_block.setToolTip(self.i18n.t("DELETE_BLOCK_TIP"))
        self.act_move_block_up.setToolTip(self.i18n.t("MOVE_UP_TIP"))
        self.act_move_block_down.setToolTip(self.i18n.t("MOVE_DOWN_TIP"))
        self.act_insert_block.setStatusTip(self.i18n.t("ADD_BLOCK_TIP"))
        self.act_insert_instr_block.setStatusTip(self.i18n.t("ADD_INSTR_BLOCK_TIP"))
        self.act_delete_block.setStatusTip(self.i18n.t("DELETE_BLOCK_TIP"))
        self.act_move_block_up.setStatusTip(self.i18n.t("MOVE_UP_TIP"))
        self.act_move_block_down.setStatusTip(self.i18n.t("MOVE_DOWN_TIP"))

        self.top_panel.retranslate(self.i18n)
        self.bottom_panel.retranslate(self.i18n)
        for block_widget in self.block_widgets:
            block_widget.retranslate()
        self.menu_bar.retranslate(
            file_menu_title=self.i18n.t("FILE_MENU"),
            edit_menu_title=self.i18n.t("EDIT_MENU"),
            languages_menu_title=self.i18n.t("LANGUAGES_MENU"),
        )
        self.act_edit_undo.setText(self.i18n.t("UNDO"))
        self.act_edit_undo.setToolTip(self.i18n.t("UNDO_TIP"))
        self.act_edit_redo.setText(self.i18n.t("REDO"))
        self.act_edit_redo.setToolTip(self.i18n.t("REDO_TIP"))
        self._update_language_actions()

    def apply_project_to_controls(self):
        if self.panel_controller is not None:
            self.panel_controller.update_top_panel()
        self._update_language_actions()

        if self.panel_controller is not None:
            self.panel_controller.update_blocks()

    def _on_toggle_reading_mode(self, checked: bool) -> None:
        self.reading_controller.set_enabled(checked)
    
    def _on_reading_mode_changed(self, enabled: bool) -> None:
        # Синхронизируем состояние кнопки в top_panel
        self.top_panel.reading_btn.blockSignals(True)
        self.top_panel.reading_btn.setChecked(enabled)
        self.top_panel.reading_btn.blockSignals(False)

        if self.panel_controller is not None:
            self.panel_controller.on_external_reading_change(enabled)

        self.root_layout.setContentsMargins(0, 0, 0, 0)
        if enabled:
            self.content_layout.setContentsMargins(40, 48, 40, 40)
        else:
            self.content_layout.setContentsMargins(12, 48, 12, 12)

    def _apply_language_selection(self, lang: str) -> None:
        if lang not in ("en", "ru"):
            lang = "en"
        if lang == self.project.lang:
            self._update_language_actions()
            return

        self.project.lang = lang
        self.i18n.lang = lang
        self.apply_language_to_ui()
        self.rebuild_all()
        if not self._building_ui:
            self.mark_modified(True)
        self._update_language_actions()

    def _on_language_action(self, lang: str) -> None:
        if self._building_ui:
            return
        self._apply_language_selection(lang)

    def _update_language_actions(self) -> None:
        lang = self.project.lang
        self.act_language_english.setChecked(lang == "en")
        self.act_language_russian.setChecked(lang == "ru")

    def on_controls_changed(self):
        if self.panel_controller is not None:
            self.panel_controller.update_blocks()
        if not self._building_ui:
            self.mark_modified(True)

    def _connect_top_panel_signals(self) -> None:
        if self.panel_controller is None:
            return
        self.top_panel.targetChanged.connect(self.panel_controller.on_target_changed)
        self.top_panel.toleranceChanged.connect(self.panel_controller.on_tolerance_changed)
        self.top_panel.readingModeToggled.connect(self.panel_controller.on_reading_toggled)
        self.top_panel.navigationRequested.connect(self._on_navigation_requested)

    # ---- responsive panels ----
    # ---- file ops ----
    def mark_modified(self, modified: bool) -> None:
        self.file_ops.mark_modified(modified)
        if modified and not self._autosave_timer.isActive():
            self._autosave_timer.start()

    def _flush_autosave(self) -> None:
        save_autosave(self.project)

    def changeEvent(self, event) -> None:
        """Autosave when window loses focus or is minimized."""
        if event.type() in (
            QEvent.Type.WindowDeactivate,
            QEvent.Type.ApplicationStateChange,
        ):
            if self._modified:
                save_autosave(self.project)
        super().changeEvent(event)

    def focusOutEvent(self, event) -> None:
        """Autosave when focus leaves the window."""
        if self._modified:
            save_autosave(self.project)
        super().focusOutEvent(event)

    def closeEvent(self, event):
        # Flush pending autosave synchronously before closing
        self._autosave_timer.stop()
        if self._modified:
            save_autosave(self.project)
        self.file_ops.close_event(event)


    # ---- nav / blocks ----
    def _on_undo(self):
        focused = QApplication.focusWidget()
        if isinstance(focused, SyllableEdit):
            focused.undo()
        else:
            for bw in reversed(self.block_widgets):
                for edit in reversed(bw.line_edits):
                    edit.undo()
                    return

    def _on_redo(self):
        focused = QApplication.focusWidget()
        if isinstance(focused, SyllableEdit):
            focused.redo()
        else:
            for bw in reversed(self.block_widgets):
                for edit in reversed(bw.line_edits):
                    edit.redo()
                    return

    def rebuild_all(self):
        self._building_ui = True
        try:
            clear_layout(self.blocks_layout)
            self.block_widgets = []

            for idx, b in enumerate(self.project.blocks):
                bw = BlockWidget(
                    b, idx, self.i18n, self.project, self.block_controller, parent=self.canvas_container
                )
                bw.set_index(idx)

                bw.activeChanged.connect(self._on_block_active)
                bw.requestInsertLyricsAfter.connect(
                    lambda bid, count, navigator=self.block_navigator: navigator.insert_block_after(bid, count)
                )
                bw.requestInsertInstrumentalAfter.connect(self.block_navigator.insert_instrumental_block_after)
                bw.requestDelete.connect(self.block_navigator.delete_block)
                bw.requestMoveUp.connect(lambda bid, delta=-1: self.block_navigator.move_block(bid, delta))
                bw.requestMoveDown.connect(lambda bid, delta=1: self.block_navigator.move_block(bid, delta))
                bw.sectionChanged.connect(lambda bid, _sec: self.block_navigator.on_section_changed())
                bw.contentChanged.connect(lambda _bid: self.block_navigator.handle_block_content_changed())
                bw.instructionChanged.connect(lambda _bid: self.block_navigator.on_section_changed())

                bw.requestEnterNext.connect(self.block_navigator.enter_from_block_line)
                bw.requestMoveFocusUp.connect(self.block_navigator.move_up_from_block_line)
                bw.requestMoveFocusDown.connect(self.block_navigator.move_down_from_block_line)

                self.blocks_layout.addWidget(bw)
                self.block_widgets.append(bw)

            self.blocks_layout.addStretch(1)
            if self.block_navigator is not None:
                self.block_navigator.on_blocks_rebuilt()
        finally:
            self._building_ui = False

        self.on_controls_changed()
        self._refresh_navigation_combo()

    def _on_navigation_requested(self, index: int) -> None:
        if self.block_navigator is None:
            return
        self.block_navigator.on_navigation_requested(index)

    def _update_navigation_combo(self, items: List[str], current_index: int) -> None:
        self.top_panel.set_navigation_items(items, current_index)

    def _set_navigation_combo_index(self, index: int) -> None:
        self.top_panel.set_navigation_index(index)

    def _refresh_navigation_combo(self) -> None:
        if self.block_navigator is None:
            return
        items = self.block_navigator.navigation_items()
        if not items and self.project.blocks:
            self.block_navigator.rebuild_nav()
            items = self.block_navigator.navigation_items()
        current = self.block_navigator.current_navigation_index()
        self._update_navigation_combo(items, current)
        self._set_navigation_combo_index(current)

    def _on_block_active(self, block_id: str) -> None:
        if self.block_navigator is None:
            return
        self.block_navigator.on_block_active(block_id)
        self._set_navigation_combo_index(self.block_navigator.current_navigation_index())

    def insert_block_after_active(self) -> None:
        if self.block_navigator is not None:
            self.block_navigator.insert_block_after_active()
            self._refresh_navigation_combo()

    def insert_instrumental_after_active(self) -> None:
        if self.block_navigator is not None:
            self.block_navigator.insert_instrumental_after_active()
            self._refresh_navigation_combo()

    def delete_active_block(self) -> None:
        if self.block_navigator is not None:
            self.block_navigator.delete_active_block()
            self._refresh_navigation_combo()