timer.py

# timer.py
from dataclasses import dataclass
from utils import load_presets, get_settings
import sys, time, math, ctypes, os
from PyQt5 import QtCore, QtGui, QtWidgets
from PyQt5.QtGui import QPainter, QPixmap, QColor, QIcon, QFontDatabase, QDesktopServices, QPainterPath
from PyQt5.QtWidgets import QStyle, QSizePolicy, QSystemTrayIcon, QMenu, QAction, QApplication, QGraphicsDropShadowEffect
from PyQt5.QtCore import QPropertyAnimation, QAbstractAnimation, QRect, Qt, QTimer, QUrl
from PyQt5.QtMultimedia import QSound, QMediaPlayer, QMediaContent
from winapi import (
    taskbar_rect_edge, SetWindowPos, HWND_TOPMOST,
    SWP_NOMOVE, SWP_NOSIZE, SWP_NOACTIVATE,
    GetSM, GetFG, GetRect, RECT,
    SM_CXSCREEN, SM_CYSCREEN,
    HWND_NOTOPMOST,
)
from dialogs import SettingsDialog
from menu    import TimerMenu
from constants import (
    SETTINGS_ICON,
    TRAY_ICON,
    DEFAULT_SOUND,
    MAX_SOUND_BYTES,
    TOPMOST_REASSERT_INTERVAL_MS,
    asset_exists,
    KEY_TIMER_ALWAYS_ON_TOP,
    KEY_TIMER_MINIMIZE_TO_TRAY,
    KEY_TIMER_AUTO_START,
    KEY_TIMER_COUNT_DIRECTION,
    KEY_APPEARANCE_THEME,
    KEY_APPEARANCE_PROGRESS_COLOR,
    KEY_APPEARANCE_FONT,
    KEY_APPEARANCE_FONT_SIZE_LEGACY,
    KEY_APPEARANCE_UI_FONT_SIZE,
    KEY_APPEARANCE_TIMER_FONT_SIZE,
    KEY_ALERTS_SOUND_ENABLED,
    KEY_ALERTS_SOUND_FILE,
    KEY_ALERTS_BLINK_ENABLED,
    KEY_ALERTS_BLINK_FREQ,
    KEY_GENERAL_AUTO_UPDATE_ENABLED,
    KEY_GENERAL_UPDATE_INTERVAL,
)
from logging_config import log_exceptions
from update_checker import UpdateChecker
import logging
from i18n import _, tr


@dataclass
class TimerState:
    """
    Минимальное выделение состояния таймера из UI.
    Хранит timer-domain данные и даёт безопасные операции перехода состояния.
    """
    duration: float = 0.0
    start_time: float = 0.0
    elapsed: float = 0.0
    running: bool = False

    def add_duration(self, seconds: int) -> None:
        self.duration += float(seconds)

    def set_duration(self, seconds: int) -> None:
        self.duration = float(seconds)
        self.elapsed = 0.0
        self.running = False
        self.start_time = 0.0

    def toggle_start_pause(self, now: float | None = None) -> bool:
        """
        Переключает running<->paused.
        Возвращает новое состояние running.
        """
        if not self.duration:
            return self.running

        if now is None:
            now = time.monotonic()

        if not self.running:
            self.start_time = now - self.elapsed
            self.running = True
        else:
            self.running = False

        return self.running

    def reset(self) -> None:
        self.duration = 0.0
        self.elapsed = 0.0
        self.running = False
        self.start_time = 0.0

    def tick(self, now: float | None = None) -> bool:
        """
        Обновляет elapsed, если таймер запущен.
        Возвращает True, если таймер именно на этом тике завершился.
        """
        if not self.running:
            return False

        if now is None:
            now = time.monotonic()

        self.elapsed = min(now - self.start_time, self.duration)

        if self.elapsed >= self.duration:
            self.running = False
            return True

        return False

    def clamped_elapsed(self) -> float:
        if self.duration <= 0.0:
            return 0.0
        return min(float(self.elapsed), float(self.duration))

    def progress_ratio_elapsed(self) -> float:
        """
        Прогресс по прошедшему времени: 0.0 .. 1.0
        """
        if self.duration <= 0.0:
            return 0.0
        return self.clamped_elapsed() / float(self.duration)

    def progress_ratio_for_direction(self, count_direction: str) -> float:
        """
        Возвращает progress ratio для визуализации:
        - up   -> растёт по elapsed
        - down -> уменьшается по remaining
        """
        ratio_elapsed = self.progress_ratio_elapsed()

        if count_direction == "down":
            return 1.0 - ratio_elapsed

        return ratio_elapsed

    def display_total_seconds(self, count_direction: str) -> float:
        """
        Возвращает значение времени, которое должно быть показано в UI:
        - down -> remaining
        - up   -> elapsed, а если таймер ещё не стартовал, то duration
        """
        dur = float(self.duration)
        el = self.clamped_elapsed()

        if count_direction == "down":
            return max(dur - el, 0.0)

        return el if (self.running or el > 0.0) else dur


class TaskbarTimer(QtWidgets.QMainWindow):
    MIN_LEN, WIDTH_RATIO = 60, 0.085
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

        icon_path = SETTINGS_ICON
        if asset_exists(icon_path):
            self.setWindowIcon(QIcon(icon_path))
        else:
            logging.getLogger(__name__).warning("Window icon asset missing: %s", icon_path)

        self.setWindowFlags(
            QtCore.Qt.FramelessWindowHint |
            QtCore.Qt.Tool
        )

        # Мягкая тень вокруг таймера (визуально "плавает" над рабочим столом)
        shadow = QGraphicsDropShadowEffect(self)
        shadow.setBlurRadius(16)
        shadow.setOffset(0, 3)
        shadow.setColor(QtGui.QColor(0, 0, 0, 160))
        self.setGraphicsEffect(shadow)

        # Следим за сменой состояния приложения только в рамках topmost-policy
        app = QtWidgets.QApplication.instance()
        app.applicationStateChanged.connect(self._on_application_state_changed)
        app.aboutToQuit.connect(self.shutdown)

        self._shutting_down = False

        # ─── DPI scale (ВАЖНО для 125% / 150%) ───
        sg = QtWidgets.QApplication.primaryScreen().geometry()
        self.sw, self.sh = sg.width(), sg.height()

        self._base_style = ""
        self._always_on_top = False
        self._topmost_guard_enabled = False

        # — состояние таймера —
        self._timer_state = TimerState()

        # — drag’n’drop —
        self._drag = False
        self._off  = QtCore.QPoint()

        # hover-состояние для визуального подсвета рамки
        self._hover = False

        self._titlebar_height = 0

        self.time_font_family = "Arial"
        # Размер шрифта (по умолчанию)
        self.time_font_size   = 12
        self._count_direction = "up"

        # — параметры «мигания» по завершении —
        self.blink_min_width    = 2
        self.blink_max_width    = 8
        self.blink_start_time   = None
        self.blink_pulse_freq   = 2.0     # Гц
        self.blink_border_width = 2

        self.orientation = "horizontal"   # или vertical / top / bottom / left / right
        self.snap_side   = None           # текущая «прилипшая» грань
        self.W = self.H = self._hW = self._hH = 0

        # — вспомогательные окна —
        self.menu = None
        self.settings_dialog = None

        # — tray/runtime availability —
        self.tray = None
        self.tray_menu = None
        self.tray_toggle_action = None
        self.tray_settings_action = None
        self.tray_exit_action = None
        self._tray_available = False

        # начальная позиция
        self._place_horizontal()
        self._snap_and_orient()

        # — два QTimer’а: UI (~30 FPS) и логика (~5 FPS) —
        self._ui_timer    = QtCore.QTimer(self, timeout=self.update)
        self._ui_timer.start(33)   # ~30 FPS для перерисовки (метод paintEvent)

        self._logic_timer = QtCore.QTimer(self, timeout=self._tick)
        self._logic_timer.start(26)

        # Таймер для периодического подтверждения TOPMOST только когда policy включена
        self._stay_top_timer = QtCore.QTimer(self, timeout=self._on_topmost_guard_tick)
        self._stay_top_timer.setInterval(int(TOPMOST_REASSERT_INTERVAL_MS))

        # кэш метрики tightBoundingRect для текста времени
        self._prev_label  = ""
        self._tight_cache = QtCore.QRect()

        logger = logging.getLogger(__name__)
        logger.debug(
            "BASE_DIR     = %r",
            os.path.dirname(sys.executable) if getattr(sys, "frozen", False) else os.path.dirname(__file__),
        )
        logger.debug("TRAY_ICON    = %r", TRAY_ICON)
        logger.debug("Icon exists? = %s", os.path.exists(TRAY_ICON))
        logger.debug("Tray avail?  = %s", QSystemTrayIcon.isSystemTrayAvailable())

        self._init_tray()

        self._player = QMediaPlayer(self)

        # Проверка обновлений
        self._update_checker = UpdateChecker(self)
        self._update_checker.update_available.connect(self._handle_update_available)
        self._update_checker.update_not_available.connect(self._handle_update_not_available)
        self._update_checker.update_failed.connect(self._handle_update_failed)

        if self._tray_available and self.tray is not None:
            self.tray.messageClicked.connect(self._on_update_click)

        self._update_url = None
        self._shutdown_in_progress = False

        self._hide_from_taskbar()
        self.apply_settings()
        self.show()

    # ──────────────────────────────────────────────────────────────
    #  timer state compatibility layer
    # ──────────────────────────────────────────────────────────────
    @property
    def duration(self) -> float:
        return self._timer_state.duration

    @duration.setter
    def duration(self, value: float) -> None:
        self._timer_state.duration = float(value)

    @property
    def start_time(self) -> float:
        return self._timer_state.start_time

    @start_time.setter
    def start_time(self, value: float) -> None:
        self._timer_state.start_time = float(value)

    @property
    def elapsed(self) -> float:
        return self._timer_state.elapsed

    @elapsed.setter
    def elapsed(self, value: float) -> None:
        self._timer_state.elapsed = float(value)

    @property
    def running(self) -> bool:
        return self._timer_state.running

    @running.setter
    def running(self, value: bool) -> None:
        self._timer_state.running = bool(value)

    def _should_keep_topmost(self) -> bool:
        """
        Единая policy-проверка:
        topmost поддерживается только если:
        - приложение не в shutdown
        - настройка always_on_top включена
        """
        return (not getattr(self, "_shutting_down", False)) and bool(getattr(self, "_always_on_top", False))

    def _set_topmost_guard_enabled(self, enabled: bool) -> None:
        """
        Управляет периодическим guard-таймером topmost.
        Идемпотентно.
        """
        self._topmost_guard_enabled = bool(enabled)

        if not hasattr(self, "_stay_top_timer") or self._stay_top_timer is None:
            return

        if self._topmost_guard_enabled:
            if not self._stay_top_timer.isActive():
                self._stay_top_timer.start()
        else:
            if self._stay_top_timer.isActive():
                self._stay_top_timer.stop()

    def _refresh_topmost_if_needed(self) -> None:
        """
        Лёгкая точка входа для мест, где нужно восстановить TOPMOST
        после show/move/snap, но только если policy реально включена.
        """
        if self._should_keep_topmost():
            self._force_topmost()

    def _on_application_state_changed(self, _state) -> None:
        """
        При смене состояния приложения восстанавливаем TOPMOST только если policy активна.
        """
        if self._should_keep_topmost():
            QtCore.QTimer.singleShot(0, self._force_topmost)

    def _on_topmost_guard_tick(self) -> None:
        """
        Periodic topmost reassertion under active policy.
        """
        if self._should_keep_topmost():
            self._force_topmost()

    def _init_tray(self) -> None:
        """
        Инициализирует tray subsystem.
        Если tray или иконка недоступны — приложение продолжает работу
        в controlled degraded mode без tray integration.
        """
        logger = logging.getLogger(__name__)

        self._tray_available = False
        self.tray = None
        self.tray_menu = None
        self.tray_toggle_action = None
        self.tray_settings_action = None
        self.tray_exit_action = None

        if not QSystemTrayIcon.isSystemTrayAvailable():
            logger.warning("System tray is not available; running without tray integration")
            return

        if not asset_exists(TRAY_ICON):
            logger.warning("Tray icon asset missing; running without tray integration: %s", TRAY_ICON)
            return

        icon = QIcon(TRAY_ICON)
        logger.debug("Icon isNull? = %s", icon.isNull())

        if icon.isNull():
            logger.warning("Tray icon is invalid; running without tray integration")
            return
        
        tray = QSystemTrayIcon(icon, self)
        tray.setToolTip(_("tray_tooltip"))
        tray.activated.connect(self.on_tray_icon_activated)

        tray_menu = QMenu(self)

        tray_toggle_action = QAction(_("tray_show_hide"), self)
        tray_toggle_action.triggered.connect(
            lambda: QtCore.QTimer.singleShot(0, self._toggle_visibility)
        )
        tray_menu.addAction(tray_toggle_action)

        tray_menu.addSeparator()

        tray_settings_action = QAction(_("tray_settings"), self)
        tray_settings_action.triggered.connect(self._open_settings)
        tray_menu.addAction(tray_settings_action)

        tray_menu.addSeparator()

        tray_exit_action = QAction(_("tray_exit"), self)
        tray_exit_action.triggered.connect(QtWidgets.QApplication.quit)
        tray_menu.addAction(tray_exit_action)

        tray.setContextMenu(tray_menu)

        self.tray = tray
        self.tray_menu = tray_menu
        self.tray_toggle_action = tray_toggle_action
        self.tray_settings_action = tray_settings_action
        self.tray_exit_action = tray_exit_action
        self._tray_available = True

        self._apply_tray_menu_style()
        self._retranslate_tray_menu()

        try:
            self.tray.show()
            self.tray.setVisible(True)
        except Exception:
            logger.exception("Failed to show tray icon; switching to degraded mode")
            try:
                tray.hide()
                tray.setContextMenu(None)
            except Exception:
                logger.exception("Failed to cleanup tray after startup failure")

            self.tray = None
            self.tray_menu = None
            self.tray_toggle_action = None
            self.tray_settings_action = None
            self.tray_exit_action = None
            self._tray_available = False

    def _safe_show_tray_message(
        self,
        title: str,
        message: str,
        icon=QSystemTrayIcon.Information,
        timeout_ms: int = 5000,
    ) -> bool:
        """
        Безопасно показывает tray notification только если tray subsystem доступен.
        """
        if not getattr(self, "_tray_available", False):
            return False

        if getattr(self, "_shutting_down", False):
            return False

        if not hasattr(self, "tray") or self.tray is None:
            return False

        try:
            self.tray.showMessage(title, message, icon, timeout_ms)
            return True
        except Exception:
            logging.getLogger(__name__).exception("Failed to show tray message")
            return False

    def _toggle_visibility(self) -> None:
        """
        • Если таймер полностью видим и НЕ свёрнут → прячем (`hide`).
        • В остальных случаях → показываем, раскручиваем из minimize,
        поднимаем поверх и снова делаем topmost.
        """
        minimized = bool(self.windowState() & QtCore.Qt.WindowMinimized)
        fully_visible = self.isVisible() and not minimized

        if fully_visible:
            self.hide()
            return

        # снимаем флаг Minimized, если он есть
        if minimized:
            self.setWindowState(self.windowState() & ~QtCore.Qt.WindowMinimized)

        self.show()          # делает видимым
        self.raise_()        # поверх других окон
        self.activateWindow()
        self._refresh_topmost_if_needed()
        
    def _ensure_settings_dialog(self) -> None:
        """
        Гарантирует single reusable instance окна настроек.
        Создание и wiring выполняются только один раз.
        """
        if hasattr(self, "settings_dialog") and self.settings_dialog is not None:
            return

        self.settings_dialog = SettingsDialog()
        self.settings_dialog.settings_changed.connect(self.apply_settings)
        self.settings_dialog.check_updates.connect(self._do_autoupdate)

    def _open_settings(self):
        self._ensure_settings_dialog()

        if not self.settings_dialog.isVisible():
            self._position_dialog(self.settings_dialog)
            self.settings_dialog.show()

        self.settings_dialog.raise_()
        self.settings_dialog.activateWindow()

    def apply_settings(self):
        settings = get_settings()

        # 1) чекбокс «Всегда поверх окон»
        always_on_top = settings.value(KEY_TIMER_ALWAYS_ON_TOP, False, type=bool)
        self._always_on_top = always_on_top         # ← запоминаем

        # запустить / остановить сторож-таймер
        # синхронизируем topmost guard policy
        self._set_topmost_guard_enabled(always_on_top)

        # применяем флаги окна (без show!)
        self._apply_window_flags(always_on_top)

        # ↓ один вызов, чтобы сразу выставить нужный уровень TOPMOST/NOTOPMOST
        self._force_topmost()

        # 2) Флаг «Сворачивать в трей при старте»
        self.minimize_to_tray = settings.value(KEY_TIMER_MINIMIZE_TO_TRAY, False, type=bool)
        if self.minimize_to_tray:
            self.hide()
        else:
            self.show()
            
        # 3) Флаг «Автостарт при добавлении времени»
        self.auto_start_on_add = settings.value(KEY_TIMER_AUTO_START, False, type=bool)

        self._count_direction = settings.value(KEY_TIMER_COUNT_DIRECTION, "up", type=str)

        # === Внешний вид ===

        # 4) Тема: «system», «light» или «dark»
        theme = settings.value(KEY_APPEARANCE_THEME, "dark")
        self._theme = theme
        if theme == "dark":
            # устанавливаем только фон окна таймера (белая рамка/текст будет рисоваться вручную в paintEvent)
            self.setStyleSheet(self._base_style + "background:#202020;")
        elif theme == "light":
            self.setStyleSheet(self._base_style + "background:#FFFFFF;")

        # обновляем стиль контекстного меню трея под текущую тему
        self._apply_tray_menu_style()

        # 5) Цвет прогресс-бара (он остаётся без изменений)
        color = settings.value(KEY_APPEARANCE_PROGRESS_COLOR, "#55FF55")
        self.progress_color = QtGui.QColor(color)

        # 6) Шрифт (семейство) — общий, размеры раздельно
        font_family = settings.value(KEY_APPEARANCE_FONT, self.time_font_family, type=str)

        legacy_size = settings.value(KEY_APPEARANCE_FONT_SIZE_LEGACY, self.time_font_size, type=int)
        ui_size     = settings.value(KEY_APPEARANCE_UI_FONT_SIZE, legacy_size, type=int)
        timer_size  = settings.value(KEY_APPEARANCE_TIMER_FONT_SIZE, legacy_size, type=int)

        if font_family:
            self.time_font_family = font_family

        # размер цифр таймера (только paintEvent)
        if timer_size:
            self.time_font_size = int(timer_size)

        # глобальный размер UI (все виджеты/окна)
        app = QtWidgets.QApplication.instance()
        if app is not None:
            app.setFont(QtGui.QFont(self.time_font_family, int(ui_size)))


        # === Оповещения ===

        # 6) Включён ли звук при окончании
        self.sound_enabled = settings.value(KEY_ALERTS_SOUND_ENABLED, False, type=bool)

        # 7) Путь к файлу звука
        configured_sound = settings.value(KEY_ALERTS_SOUND_FILE, "", type=str)

        if configured_sound:
            self.sound_file = configured_sound
        elif asset_exists(DEFAULT_SOUND):
            self.sound_file = DEFAULT_SOUND
        else:
            self.sound_file = ""

        # 8) Включено ли мигание рамки при окончании
        self.blink_enabled = settings.value(KEY_ALERTS_BLINK_ENABLED, False, type=bool)

        if not self.blink_enabled:
            self.blink_start_time = None
        # 9) Частота мигания (в герцах)
        self.blink_pulse_freq = settings.value(KEY_ALERTS_BLINK_FREQ, 2.0, type=float)

        # === Пресеты кнопок быстрого добавления времени ===

        presets = load_presets()
        self._build_menu(presets)

        # === Автообновление ===

        # 12) Флаг «Включить автообновление»
        autoupd = settings.value(KEY_GENERAL_AUTO_UPDATE_ENABLED, False, type=bool)

        # 13) Интервал проверки (в минутах)
        interval = settings.value(KEY_GENERAL_UPDATE_INTERVAL, 10080, type=int)
    
        if autoupd:
            if not hasattr(self, "_autoupd_timer"):
                self._autoupd_timer = QtCore.QTimer(self)
                self._autoupd_timer.timeout.connect(self._do_autoupdate)
            self._autoupd_timer.start(interval * 60 * 1000)
        else:
            if hasattr(self, "_autoupd_timer"):
                self._autoupd_timer.stop()
        
        # язык мог измениться → обновляем меню трея
        self._retranslate_tray_menu()


        
    def on_tray_icon_activated(self, reason):
        """
        Обработка кликов по иконке.
        QSystemTrayIcon.Trigger — обычный клик ЛКМ
        QSystemTrayIcon.Context — ПКМ (контекстное меню обрабатывается автоматически)
        """
        if reason == QSystemTrayIcon.Trigger:
            if self.isVisible():
                self.hide()
            else:
                self.show()
    # ──────────────────────────────────────────────────────────────
    #  вспомогательные расчёты ориентации / размера
    # ──────────────────────────────────────────────────────────────
    def _snap_and_orient(self):
        """
        Находит ближайшую грань экрана; если таймер уже «в углу»,
        ориентацию не меняет.
        """
        sg = QtWidgets.QApplication.primaryScreen().geometry()
        self.sw, self.sh = sg.width(), sg.height()

        geo  = self.geometry()
        dists = {
            "left":   abs(geo.left()),
            "right":  abs(self.sw - geo.right()),
            "top":    abs(geo.top()),
            "bottom": abs(self.sh - geo.bottom()),
        }
        min_val   = min(dists.values())
        min_sides = [s for s, v in dists.items() if v == min_val]
        if len(min_sides) > 1:  # угол — оставляем прежнее
            return
        side = min_sides[0]
        self.snap_side   = side
        self.orientation = "horizontal" if side in ("top", "bottom") else "vertical"

    def _place_horizontal(self):
        """
        DPI-safe: используем Qt Screen geometry вместо WinAPI taskbar_rect_edge.
        Корректно работает на 100/125/150% и не "раздувает" таймер.
        """
        screen = QtWidgets.QApplication.primaryScreen()
        sg = screen.geometry()           # полный экран (DIP)
        ag = screen.availableGeometry()  # доступная область без taskbar (DIP)

        # Геометрия экрана (в DIP)
        sx, sy, sw, sh = sg.x(), sg.y(), sg.width(), sg.height()
        ax, ay, aw, ah = ag.x(), ag.y(), ag.width(), ag.height()

        # Сохраняем размеры экрана для drag/snap
        self.sw, self.sh = sw, sh

        # Определяем, где taskbar и какой он толщины (в DIP)
        # edge: 0=left,1=top,2=right,3=bottom (как у WinAPI)
        if (ay + ah) < (sy + sh):               # снизу
            edge = 3
            tb_thickness = (sy + sh) - (ay + ah)
            tb_len = sw
        elif ay > sy:                           # сверху
            edge = 1
            tb_thickness = ay - sy
            tb_len = sw
        elif ax > sx:                           # слева
            edge = 0
            tb_thickness = ax - sx
            tb_len = sh
        else:                                   # справа
            edge = 2
            tb_thickness = (sx + sw) - (ax + aw)
            tb_len = sh

        # --- Размеры таймера ---
        # Минимальная высота/ширина от шрифта (чтобы на 150% таймер не превращался в полоску)
        font = QtGui.QFont(self.time_font_family, int(self.time_font_size), QtGui.QFont.Bold)
        fm = QtGui.QFontMetrics(font)

        text_h = fm.height()
        min_h = max(28, text_h + 8)  # 16 = запас под padding/рамку

        base_h = (tb_thickness // 2) if tb_thickness > 0 else 0
        H = max(min_h, base_h)

        W = max(self.MIN_LEN, int(tb_len * self.WIDTH_RATIO))
        min_w = fm.horizontalAdvance("00:00:00") + 24  # 24 = запас под padding/рамку
        W = max(W, min_w)

        self.W, self._hW = W, W
        self.H, self._hH = H, H

        gap = 4

        # --- Позиционирование ---
        if edge == 3:          # taskbar снизу → таймер над ним
            x = sx + (sw - W) // 2
            y = (ay + ah) - H - gap
        elif edge == 1:        # taskbar сверху → таймер под ним
            x = sx + (sw - W) // 2
            y = ay + gap
        elif edge == 0:        # taskbar слева → таймер ближе к доступной области
            x = ax + gap
            y = sy + (sh - H) // 2
        else:                  # taskbar справа
            x = (ax + aw) - W - gap
            y = sy + (sh - H) // 2

        # --- Clamp, чтобы никогда не улетал за экран ---
        x = max(sx, min(x, sx + sw - W))
        y = max(sy, min(y, sy + sh - H))

        self.setGeometry(x, y, W, H)
        self._refresh_topmost_if_needed()


    def _snap(self, side: str, vertical: bool):
        """
        «Прилипает» к указанной грани экрана и,
        при необходимости, меняет ориентацию.
        """
        if vertical:
            self.W, self.H = self._hH, self._hW
        else:
            self.W, self.H = self._hW, self._hH

        if vertical:
            x = 0 if side == "left" else self.sw - self.W
            y = max(0, min(self.y(), self.sh - self.H))
        else:
            y = 0 if side == "top" else self.sh - self.H
            x = max(0, min(self.x(), self.sw - self.W))

        self.orientation = self.snap_side = side
        self.setGeometry(x, y, self.W, self.H)
        self._refresh_topmost_if_needed()
        self._close_menu()

    def _force_topmost(self):
        """
        Применяет текущую topmost policy на уровне WinAPI.
        Может как поднять окно в TOPMOST, так и снять его оттуда.
        """
        if getattr(self, "_shutting_down", False):
            return

        try:
            hwnd = int(self.winId())
        except Exception:
            return

        if not hwnd:
            return

        always = bool(getattr(self, "_always_on_top", False))
        insert_after = HWND_TOPMOST if always else HWND_NOTOPMOST

        SetWindowPos(
            hwnd,
            insert_after,
            0, 0, 0, 0,
            SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE,
        )
    
    def _retranslate_tray_menu(self):
        """Обновить текст тултипа и пунктов меню трея согласно текущему языку."""
        if not getattr(self, "_tray_available", False):
            return

        if self.tray is not None:
            self.tray.setToolTip(_("tray_tooltip"))

        if self.tray_toggle_action is not None:
            self.tray_toggle_action.setText(_("tray_show_hide"))
        if self.tray_settings_action is not None:
            self.tray_settings_action.setText(_("tray_settings"))
        if self.tray_exit_action is not None:
            self.tray_exit_action.setText(_("tray_exit"))
    
    def _apply_tray_menu_style(self) -> None:
        """
        Применить единый стиль к контекстному меню трея в зависимости от текущей темы.
        """
        if not getattr(self, "_tray_available", False):
            return

        tray_menu = getattr(self, "tray_menu", None)
        if tray_menu is None:
            return

        theme = getattr(self, "_theme", "dark")

        if theme == "dark":
            tray_menu.setStyleSheet("""
                QMenu {
                    background-color: #222222;
                    color: #F0F0F0;
                    border: 1px solid #4B8BBE;
                }
                QMenu::item:selected {
                    background-color: #3A3A3A;
                }
                QMenu::separator {
                    height: 1px;
                    background: #444444;
                    margin: 4px 8px;
                }
            """)
        else:
            tray_menu.setStyleSheet("""
                QMenu {
                    background-color: #FFFFFF;
                    color: #2B2B2B;
                    border: 1px solid #D0D0D0;
                }
                QMenu::item:selected {
                    background-color: #E6F0FA;
                }
                QMenu::separator {
                    height: 1px;
                    background: #DDDDDD;
                    margin: 4px 8px;
                }
            """)

    def _apply_window_flags(self, always_on_top: bool) -> None:
        """
        Настраивает флаги окна:
        – Frameless + Qt.Tool всегда;
        – + WindowStaysOnTopHint, если always_on_top=True.
        """
        # 1) Собираем нужный набор флагов
        flags = QtCore.Qt.FramelessWindowHint | QtCore.Qt.Tool
        if always_on_top:
            flags |= QtCore.Qt.WindowStaysOnTopHint

        # 2) Перевыставляем их
        self.setWindowFlags(flags)

        # 3) Синхронизируем уровень окна с текущей policy
        self._force_topmost()
    
    def _hide_from_taskbar(self):
        if sys.platform.startswith("win"):
            hwnd           = int(self.winId())          # дескриптор окна
            GWL_EXSTYLE    = -20
            WS_EX_APPWINDOW= 0x00040000
            WS_EX_TOOLWINDOW=0x00000080

            user32  = ctypes.windll.user32
            style   = user32.GetWindowLongW(hwnd, GWL_EXSTYLE)
            style   = (style & ~WS_EX_APPWINDOW) | WS_EX_TOOLWINDOW
            user32.SetWindowLongW(hwnd, GWL_EXSTYLE, style)

    def _destroy_menu(self) -> None:
        """
        Controlled destroy текущего TimerMenu.
        Safe to call multiple times.
        """
        if not self.menu:
            return

        try:
            self.menu.close()
            self.menu.deleteLater()
        finally:
            self.menu = None

    def _build_menu(self, presets=None) -> None:
        """
        Единая точка создания TimerMenu с консистентным wiring.
        """
        if presets is None:
            presets = load_presets()

        self._destroy_menu()

        self.menu = TimerMenu(self, presets=presets, theme=getattr(self, "_theme", "dark"))
        self.menu.add_time.connect(self._add_duration)
        self.menu.start_pause.connect(self._toggle_start_pause)
        self.menu.reset_signal.connect(self._reset_timer)
        self.menu.custom_time.connect(self._open_settings)
        self.menu.reflect_state(self.running)
    # ──────────────────────────────────────────────────────────────
    #  меню  +  диалог
    # ──────────────────────────────────────────────────────────────
    def _open_menu(self):
        """
        Открываем меню с кнопками добавления времени.
        Используем единый builder, чтобы lifecycle и wiring были детерминированными.
        """
        self._build_menu()

        # Горизонтальный таймер → меню той же ширины;
        # Вертикальный → естественная ширина (по sizeHint).
        if self.orientation in ("horizontal", "top", "bottom"):
            self.menu.setFixedWidth(self.width())
        else:
            self.menu.adjustSize()

        # Плавное появление меню
        self.menu.setWindowOpacity(0.0)
        self.menu.show()
        anim = QPropertyAnimation(self.menu, b"windowOpacity", self)
        anim.setDuration(200)
        anim.setStartValue(0.0)
        anim.setEndValue(1.0)
        anim.setEasingCurve(QtCore.QEasingCurve.InOutQuad)
        anim.start(QAbstractAnimation.DeleteWhenStopped)

        # Позиционируем ТОЛЬКО после show()
        self._position_menu()

        
    def _close_menu(self):
        if not (self.menu and self.menu.isVisible()):
            return
        anim = QPropertyAnimation(self.menu, b"windowOpacity", self)
        anim.setDuration(200)
        anim.setStartValue(self.menu.windowOpacity())
        anim.setEndValue(0.0)
        anim.setEasingCurve(QtCore.QEasingCurve.InOutQuad)
        anim.finished.connect(self.menu.close)
        anim.start(QAbstractAnimation.DeleteWhenStopped)

    # timer.py  ─ метод _position_menu --------------------------------
    def _position_menu(self):
        if not self.menu:
            return

        screen = QtWidgets.QApplication.primaryScreen()
        if screen is None:
            return

        scr = screen.geometry()

        # Используем реальную геометрию уже показанного окна,
        # а не sizeHint(), чтобы не плясать от layout-only размеров.
        self.menu.adjustSize()
        mw = self.menu.width()
        mh = self.menu.height()

        timer = QtCore.QRect(self.x(), self.y(), self.width(), self.height())

        # Раздельные зазоры:
        # side_gap — расстояние по основной оси между таймером и меню
        # cross_gap — минимальный отступ от границ экрана при clamp
        #
        # Значения подобраны под текущие border + shadow у TimerMenu и таймера.
        side_gap = 10
        cross_gap = 6

        def clamp_x(x_value: int) -> int:
            return max(scr.left() + cross_gap, min(x_value, scr.right() - mw - cross_gap))

        def clamp_y(y_value: int) -> int:
            return max(scr.top() + cross_gap, min(y_value, scr.bottom() - mh - cross_gap))

        snap_side = self.snap_side

        # Fallback на orientation только если snap_side ещё не зафиксирован.
        if snap_side not in ("left", "right", "top", "bottom"):
            if self.orientation in ("horizontal", "top", "bottom"):
                snap_side = "bottom"
            else:
                snap_side = "right"

        # ───────── LEFT SNAP → меню открываем ВПРАВО ─────────
        if snap_side == "left":
            preferred_x = timer.right() + side_gap
            fallback_x = timer.left() - mw - side_gap

            if preferred_x + mw <= scr.right() - cross_gap:
                x = preferred_x
            else:
                x = fallback_x

            y = timer.top() + (timer.height() - mh) // 2
            x = clamp_x(x)
            y = clamp_y(y)

            self.menu.move(x, y)
            self.menu.raise_()
            return

        # ───────── RIGHT SNAP → меню открываем ВЛЕВО ─────────
        if snap_side == "right":
            preferred_x = timer.left() - mw - side_gap
            fallback_x = timer.right() + side_gap

            if preferred_x >= scr.left() + cross_gap:
                x = preferred_x
            else:
                x = fallback_x

            y = timer.top() + (timer.height() - mh) // 2
            x = clamp_x(x)
            y = clamp_y(y)

            self.menu.move(x, y)
            self.menu.raise_()
            return

        # ───────── TOP SNAP → меню открываем ВНИЗ ─────────
        if snap_side == "top":
            preferred_y = timer.bottom() + side_gap
            fallback_y = timer.top() - mh - side_gap

            if preferred_y + mh <= scr.bottom() - cross_gap:
                y = preferred_y
            else:
                y = fallback_y

            x = timer.left() + (timer.width() - mw) // 2
            x = clamp_x(x)
            y = clamp_y(y)

            self.menu.move(x, y)
            self.menu.raise_()
            return

        # ───────── BOTTOM SNAP → меню открываем ВВЕРХ ─────────
        preferred_y = timer.top() - mh - side_gap
        fallback_y = timer.bottom() + side_gap

        if preferred_y >= scr.top() + cross_gap:
            y = preferred_y
        else:
            y = fallback_y

        x = timer.left() + (timer.width() - mw) // 2
        x = clamp_x(x)
        y = clamp_y(y)

        self.menu.move(x, y)
        self.menu.raise_()

    def _open_dialog(self):
        """
        Legacy stub.
        В текущем lifecycle не используется: TimerMenu открывает SettingsDialog.
        """
        self._open_settings()

    def _position_dialog(self, child):
        """
        Универсальный метод для позиционирования дочернего окна `child`
        (TimeDialog или SettingsDialog) рядом с главным таймером.
        """
        # 1) если это окно настроек – центрируем по экрану
        from dialogs import SettingsDialog
        if isinstance(child, SettingsDialog):
            scr = QtWidgets.QApplication.primaryScreen().geometry()
            dw  = child.sizeHint().width()
            dh  = child.sizeHint().height()
            cx  = scr.x() + (scr.width()  - dw) // 2
            cy  = scr.y() + (scr.height() - dh) // 2
            child.move(cx, cy)
            return

        # 2) иначе – старая логика: рядом с таймером (как было раньше)
        dw = child.sizeHint().width()
        dh = child.sizeHint().height()
        scr = QtWidgets.QApplication.primaryScreen().geometry()

        # позиционируем справа от главного окна, с отступом 10px
        x = self.x() + self.width() + 10
        y = self.y() + (self.height() - dh) // 2

        # если не помещается справа → ставим слева
        if x + dw > scr.x() + scr.width():
            x = self.x() - dw - 10

        # если не помещается ни слева, ни справа → привязываем к центру таймера
        if x < scr.x() or x + dw > scr.x() + scr.width():
            x = self.x() + (self.width() - dw) // 2
        if y < scr.y():
            y = scr.y() + 10
        elif y + dh > scr.y() + scr.height():
            y = scr.y() + scr.height() - dh - 10

        child.move(x, y)


    # ──────────────────────────────────────────────────────────────
    #  обработка мыши
    # ──────────────────────────────────────────────────────────────
    def mousePressEvent(self, e):
        if e.button() == QtCore.Qt.LeftButton:
            self._drag = True
            self._off  = e.globalPos() - self.frameGeometry().topLeft()
            self.snap_side = None
        elif e.button() == QtCore.Qt.RightButton:
            if self.menu and self.menu.isVisible():
                self._close_menu()
            else:
                self._open_menu()
        super().mousePressEvent(e)

    def mouseMoveEvent(self, e):
        if not self._drag:
            super().mouseMoveEvent(e)
            return
        pos = e.globalPos() - self._off
        x   = max(0, min(pos.x(), self.sw - self.W))
        y   = max(0, min(pos.y(), self.sh - self.H))
        self.move(x, y)
        self._refresh_topmost_if_needed()

        # определяем касание граней
        touches = [x <= 0, x + self.W >= self.sw, y <= 0, y + self.H >= self.sh]
        c = touches.count(True)
        if c == 0:
            self.snap_side = None
        elif c == 1 and self.snap_side is None:
            if touches[0]:
                self._snap("left",  True)
            elif touches[1]:
                self._snap("right", True)
            elif touches[2]:
                self._snap("top",   False)
            else:
                self._snap("bottom", False)

        if self.menu and self.menu.isVisible():
            self._position_menu()

        super().mouseMoveEvent(e)

    def mouseReleaseEvent(self, e):
        if e.button() == QtCore.Qt.LeftButton:
            self._drag = False
        super().mouseReleaseEvent(e)
    
    def enterEvent(self, event: QtCore.QEvent) -> None:
        """Курсор зашёл на таймер — чуть подсветим рамку."""
        self._hover = True
        self.update()
        super().enterEvent(event)

    def leaveEvent(self, event: QtCore.QEvent) -> None:
        """Курсор ушёл — убираем подсветку."""
        self._hover = False
        self.update()
        super().leaveEvent(event)

    def hideEvent(self, event: QtGui.QHideEvent) -> None:
        # При скрытии окна останавливаем только UI-таймер
        self._ui_timer.stop()
        super().hideEvent(event)

    def showEvent(self, event: QtGui.QShowEvent) -> None:
        # При показе – снова запускаем UI-таймер (~30 FPS)
        self._ui_timer.start(33)
        super().showEvent(event)
    
    def closeEvent(self, event: QtGui.QCloseEvent) -> None:
        self.shutdown()
        event.accept()
        super().closeEvent(event)

    def _sync_timer_ui_state(self) -> None:
        """
        Единая точка синхронизации UI после изменений timer-domain состояния.
        """
        if self.menu:
            self.menu.reflect_state(self._timer_state.running)
    # ──────────────────────────────────────────────────────────────
    #  управление временем
    # ──────────────────────────────────────────────────────────────
    @log_exceptions
    def _add_duration(self, secs: int):
        self._timer_state.add_duration(secs)
        self.blink_start_time = None

        if self.auto_start_on_add:
            if not self._timer_state.running:
                self._toggle_start_pause()
        # Если авто-старт выключен — добавление времени должно ставить таймер на паузу (только если он запущен)
        else:
            if self._timer_state.running:
                self._toggle_start_pause()

        self._sync_timer_ui_state()
        self.update()

    def _set_duration(self, secs: int):
        self._timer_state.set_duration(secs)
        self.blink_start_time = None
        self.update()

    def _toggle_start_pause(self):
        if not self._timer_state.duration:
            return

        self._timer_state.toggle_start_pause(time.monotonic())
        self._sync_timer_ui_state()

        if self._timer_state.running and getattr(self, "minimize_to_tray", False):
            self.hide()
                
    @log_exceptions
    def _reset_timer(self):
        self._timer_state.reset()
        self.blink_start_time = None
        self._sync_timer_ui_state()
        self.update()

    # ──────────────────────────────────────────────────────────────
    #  «тик» логики и перерисовка
    # ──────────────────────────────────────────────────────────────
    @log_exceptions
    def _tick(self):
        # … (логика скрытия/показа окна в зависимости от фуллскрина) …
        finished_now = self._timer_state.tick(time.monotonic())

        if finished_now:
            # --- Sound on finish ---
            if self.sound_enabled and self.sound_file:
                if os.path.isfile(self.sound_file):
                    play_sound = True

                    # size limit (anti-abuse)
                    try:
                        if os.path.getsize(self.sound_file) > int(MAX_SOUND_BYTES):
                            logging.getLogger(__name__).warning(
                                "Sound file too large, skipped: %s", self.sound_file
                            )
                            play_sound = False
                    except OSError:
                        # if size can't be read — don't block finishing
                        pass

                    if play_sound:
                        ext = os.path.splitext(self.sound_file)[1].lower()

                        if ext == ".wav":
                            QSound.play(self.sound_file)
                        else:
                            # mp3/ogg/flac/m4a/... via QMediaPlayer
                            try:
                                url = QUrl.fromLocalFile(self.sound_file)
                                self._player.setMedia(QMediaContent(url))
                                self._player.setVolume(100)
                                self._player.play()
                            except Exception:
                                logging.getLogger(__name__).exception(
                                    "Не удалось проиграть звук: %s", self.sound_file
                                )
                else:
                    logging.getLogger(__name__).warning(
                        "Звуковой файл не найден: %s", self.sound_file
                    )

            # blink only if enabled
            if self.blink_enabled:
                self.blink_start_time = time.monotonic()

            self._sync_timer_ui_state()

        self.update()

        
    @log_exceptions
    def _do_autoupdate(self):
        """Вызывается по таймеру — стартуем full-check."""
        if getattr(self, "_shutting_down", False):
            return

        if not hasattr(self, "_update_checker") or self._update_checker is None:
            return

        self._update_checker.check_for_update()

    def _set_settings_update_status(self, text: str) -> None:
        """
        Безопасно обновляет статус обновлений в settings dialog,
        если окно уже существует.
        """
        if hasattr(self, "settings_dialog") and self.settings_dialog is not None:
            try:
                self.settings_dialog.lbl_update_status.setText(text)
            except Exception:
                logging.getLogger(__name__).exception(
                    "Failed to update settings dialog update status"
                )

    def _handle_update_available(self, tag: str, url: str) -> None:
        self._update_url = url
        self._set_settings_update_status(tr("update_status_available", tag=tag))
        self._on_github_update(tag, url)

    def _handle_update_not_available(self) -> None:
        self._set_settings_update_status(_("update_status_uptodate"))
        self._on_update_not_available()

    def _handle_update_failed(self, stage: str) -> None:
        self._set_settings_update_status(tr("update_status_failed", stage=stage))
        self._on_update_failed(stage)

    def _on_github_update(self, tag: str, url: str):
        """Найден новый релиз на GitHub — сохраняем ссылку и показываем уведомление."""
        self._update_url = url
        self._safe_show_tray_message(
            _("tray_update_available_title"),
            tr("tray_update_available_message", tag=tag),
            QSystemTrayIcon.Information,
            10000,
        )

    def _on_update_failed(self, stage: str):
        logger = logging.getLogger(__name__)
        logger.warning(f"Auto-update failed at stage: {stage}")

    def _on_update_not_available(self):
        """
        Версия актуальна — показываем информационный статус.
        """
        logger = logging.getLogger(__name__)
        logger.info("No updates available — current version is up to date")

        self._safe_show_tray_message(
            _("tray_update_uptodate_title"),
            _("tray_update_uptodate_message"),
            QSystemTrayIcon.Information,
            5000,
        )

    def _on_update_click(self):
        """По клику открываем страницу релиза, если она известна."""
        if getattr(self, "_shutting_down", False):
            return

        if self._update_url:
            QDesktopServices.openUrl(QUrl(self._update_url))

    def shutdown(self) -> None:
        """
        Gracefully stop timers, tray, media player and updater.
        Safe to call multiple times.
        """
        if getattr(self, "_shutting_down", False):
            return

        self._shutting_down = True
        logger = logging.getLogger(__name__)

        try:
            self._timer_state.running = False

            if hasattr(self, "_ui_timer") and self._ui_timer.isActive():
                self._ui_timer.stop()

            if hasattr(self, "_logic_timer") and self._logic_timer.isActive():
                self._logic_timer.stop()

            self._set_topmost_guard_enabled(False)

            if hasattr(self, "_stay_top_timer") and self._stay_top_timer.isActive():
                self._stay_top_timer.stop()

            if hasattr(self, "_autoupd_timer") and self._autoupd_timer.isActive():
                self._autoupd_timer.stop()

            if hasattr(self, "_player") and self._player is not None:
                try:
                    self._player.stop()
                except Exception:
                    logger.exception("Failed to stop media player")

            if self.menu:
                try:
                    self._destroy_menu()
                except Exception:
                    logger.exception("Failed to close timer menu")

            if self.settings_dialog:
                try:
                    self.settings_dialog.allow_close_for_shutdown()
                    self.settings_dialog.close()
                    self.settings_dialog.deleteLater()
                except Exception:
                    logger.exception("Failed to close settings dialog")
                self.settings_dialog = None

            if hasattr(self, "_update_checker") and self._update_checker:
                try:
                    self._update_checker.shutdown()
                except Exception:
                    logger.exception("Failed to shutdown update checker")
                self._update_checker = None

            if self.tray is not None:
                try:
                    self.tray.messageClicked.disconnect(self._on_update_click)
                except Exception:
                    pass

                try:
                    self.tray.hide()
                    self.tray.setContextMenu(None)
                except Exception:
                    logger.exception("Failed to hide tray icon")

            self.tray = None
            self.tray_menu = None
            self.tray_toggle_action = None
            self.tray_settings_action = None
            self.tray_exit_action = None
            self._tray_available = False

            logger.info("TaskbarTimer shutdown complete")

        except Exception:
            logger.exception("TaskbarTimer shutdown failed")

    def paintEvent(self, _ev):
        p = QPainter(self)
        p.setRenderHint(QPainter.Antialiasing)

        # ─── кастомный titlebar (пока только фон) ───
        title_h = getattr(self, "_titlebar_height", 0)
        if title_h > 0:
            title_rect = QtCore.QRect(0, 0, self.W, title_h)

            if getattr(self, "_theme", "dark") == "light":
                bg = QColor(240, 240, 240, 230)
                border = QColor(180, 180, 180, 255)
            else:
                bg = QColor(32, 32, 32, 230)
                border = QColor(80, 80, 80, 255)

            # фон панели
            p.fillRect(title_rect, bg)
            # тонкая линия снизу панели
            p.setPen(QtGui.QPen(border, 1))
            p.drawLine(title_rect.bottomLeft(), title_rect.bottomRight())


        # При перетаскивании делаем таймер слегка прозрачным
        if getattr(self, "_drag", False):
            p.setOpacity(0.9)

        # Фактические размеры окна
        w = self.width()
        h = self.height()


        if self.blink_enabled and self.blink_start_time is not None:
            t     = time.monotonic() - self.blink_start_time
            alpha = int(((math.sin(2 * math.pi * self.blink_pulse_freq * t) + 1) / 2) * 255)
            bw    = self.blink_border_width
        else:
            bw    = 2
            alpha = 255

        # Лёгкая подсветка рамки при наведении курсора
        if getattr(self, "_hover", False):
            alpha = min(255, alpha + 60)
            bw = bw + 1


        is_light = (getattr(self, "_theme", "dark") == "light")

        # Визуально pure white / pure black дают разную "массу",
        # поэтому слегка выравниваем perceived thickness через цвет.
        if is_light:
            border_color = QColor(28, 28, 28, alpha)        # мягче, чем pure black
        else:
            border_color = QColor(235, 235, 235, alpha)     # мягче, чем pure white

        # Скруглённая рамка должна рисоваться не pen-ом, а как filled ring.
        # Это убирает corner artifacts ("треугольники") в углах.
        radius = 8.0

        # Небольшой внешний inset для ровного антиалиасинга по краям окна
        outer_inset = 0.5

        # Реальная толщина border ring
        border_width = float(bw)

        outer_rect = QtCore.QRectF(
            outer_inset,
            outer_inset,
            max(0.0, w - 2.0 * outer_inset),
            max(0.0, h - 2.0 * outer_inset),
        )

        inner_border_rect = QtCore.QRectF(
            outer_rect.left() + border_width,
            outer_rect.top() + border_width,
            max(0.0, outer_rect.width() - 2.0 * border_width),
            max(0.0, outer_rect.height() - 2.0 * border_width),
        )

        outer_path = QPainterPath()
        outer_path.addRoundedRect(outer_rect, radius, radius)

        inner_radius = max(0.0, radius - border_width)
        inner_path = QPainterPath()
        if inner_border_rect.width() > 0.0 and inner_border_rect.height() > 0.0:
            inner_path.addRoundedRect(inner_border_rect, inner_radius, inner_radius)

        border_path = outer_path.subtracted(inner_path)

        p.setPen(QtCore.Qt.NoPen)
        p.setBrush(border_color)
        p.drawPath(border_path)

        # Внутренний "контентный" прямоугольник (для прогресса и текста)
        content_padding = 2.0
        inner_rect = QtCore.QRectF(
            inner_border_rect.left() + content_padding,
            inner_border_rect.top() + content_padding,
            max(0.0, inner_border_rect.width() - 2.0 * content_padding),
            max(0.0, inner_border_rect.height() - 2.0 * content_padding),
        )

        # 2) Прогресс-бар
        count_direction = getattr(self, "_count_direction", "up")
        is_down = (count_direction == "down")
        ratio_elapsed = self._timer_state.progress_ratio_elapsed()
        ratio = self._timer_state.progress_ratio_for_direction(count_direction)

        brush = QtGui.QBrush(self.progress_color)
        
        # Для красоты: скругление прогресс-бара немного меньше, чем у рамки
        def _bar_radius(width, height):
            if width <= 0 or height <= 0:
                return 0.0
            r = min(radius - 2.0, height / 2.0, width / 2.0)
            return max(0.0, r)

        inner_left = inner_rect.left()
        inner_top = inner_rect.top()
        inner_w = inner_rect.width()
        inner_h = inner_rect.height()

        if inner_w > 0.0 and inner_h > 0.0:
            if self.orientation in ("horizontal", "top", "bottom"):
                # горизонталь: бар растёт слева направо
                if ratio > 0.0:
                    fill_w = inner_w * ratio
                    bar_rect = QtCore.QRectF(
                        inner_left,
                        inner_top,
                        fill_w,
                        inner_h,
                    )
                    r = _bar_radius(fill_w, inner_h)
                    path = QPainterPath()
                    path.addRoundedRect(bar_rect, r, r)
                    p.fillPath(path, brush)
            else:
                # вертикаль
                if is_down:
                    # при "down" – бар «сидит» у нижнего края и сжимается
                    if ratio > 0.0:
                        fill_h = inner_h * ratio
                        bar_rect = QtCore.QRectF(
                            inner_left,
                            inner_top + (inner_h - fill_h),
                            inner_w,
                            fill_h,
                        )
                        r = _bar_radius(inner_w, fill_h)
                        path = QPainterPath()
                        path.addRoundedRect(bar_rect, r, r)
                        p.fillPath(path, brush)
                else:
                    # "up" – заполняем снизу вверх по elapsed
                    if ratio_elapsed > 0.0:
                        fill_h = inner_h * ratio_elapsed
                        bar_rect = QtCore.QRectF(
                            inner_left,
                            inner_top + (inner_h - fill_h),
                            inner_w,
                            fill_h,
                        )
                        r = _bar_radius(inner_w, fill_h)
                        path = QPainterPath()
                        path.addRoundedRect(bar_rect, r, r)
                        p.fillPath(path, brush)
        
        # 3) Текст «HH:MM:SS»
        total = self._timer_state.display_total_seconds(count_direction)

        hh, rem = divmod(int(total), 3600)
        mm, ss  = divmod(rem, 60)
        label   = f"{hh:02d}:{mm:02d}:{ss:02d}"

        # 4) Шрифт пользователя
        font = QtGui.QFont(self.time_font_family, self.time_font_size, QtGui.QFont.Bold)
        p.setFont(font)

        # 5) Прямоугольник рисования текста (ниже titlebar)
        rect = self.rect()  # QRect(0, 0, self.W, self.H)
        title_h = getattr(self, "_titlebar_height", 0)
        if title_h > 0 and self.orientation in ("horizontal", "top", "bottom"):
            rect = rect.adjusted(0, title_h, 0, 0)


        # 5) Прямоугольник рисования текста (внутри inner_rect)
        text_rect = inner_rect

        # Состояния: при паузе чуть приглушаем текст
        running_or_blink = self.running or (self.blink_enabled and self.blink_start_time is not None)
        alpha_text = 255 if running_or_blink else 200

        if is_light:
            stroke_color = QColor(255, 255, 255, alpha_text)
            fill_color   = QColor(0, 0, 0, alpha_text)
        else:
            stroke_color = QColor(0, 0, 0, alpha_text)
            fill_color   = QColor(255, 255, 255, alpha_text)

        # 6) Рисуем текст с обводкой
        if self.orientation in ("horizontal", "top", "bottom"):
            p.setPen(QtGui.QPen(stroke_color, 3))
            p.drawText(text_rect, Qt.AlignCenter, label)
            p.setPen(QtGui.QPen(fill_color, 1))
            p.drawText(text_rect, Qt.AlignCenter, label)
        else:
            # вертикальный режим (поворот текста)
            p.save()
            p.translate(w / 2.0, h / 2.0)
            p.rotate(-90)

            # При повороте меняются местами ширина/высота
            rotated_rect = QtCore.QRectF(
                -inner_h / 2.0,
                -inner_w / 2.0,
                inner_h,
                inner_w,
            )

            p.setPen(QtGui.QPen(stroke_color, 3))
            p.drawText(rotated_rect, Qt.AlignCenter, label)
            p.setPen(QtGui.QPen(fill_color, 1))
            p.drawText(rotated_rect, Qt.AlignCenter, label)
            p.restore()

        p.end()