cowork-local/presentation/shell/main_window.py

"""Cửa sổ chính — R08-T10.

Bóc nguyên khối ra khỏi ``app.py``. ``app.py`` giờ chỉ còn điểm vào của chương
trình: dựng QApplication, gọi Composition Root, mở cửa sổ.

Vì sao tách: ``app.py`` là nơi mọi thứ đổ về — nó vừa là điểm vào, vừa giữ cửa
sổ, vừa giữ thanh điều hướng, vừa giữ thanh trên cùng. Ai sửa bất cứ mảng nào
cũng phải mở đúng một file 1.293 dòng, và ba người sửa ba mảng khác nhau thì
đụng nhau ở cùng một chỗ.
"""
from __future__ import annotations

"""
pages (Dashboard / Schedule / Workspace / Cowork / Structure) and top bar."""

import sys

from PySide6.QtCore import Qt, QTimer
from PySide6.QtWidgets import QApplication, QLabel, QMainWindow, QStackedWidget, QVBoxLayout, QWidget

from ... import DISPLAY_NAME, __version__
from ...i18n import on_language_changed, tr
from .branding import app_icon
from .lifecycle_coordinator import LifecycleCoordinator
from .page_registry import PageRegistryMixin
from .rail_project import RailProjectMixin
from .session_events import SessionEventsMixin
from .toast import Toast
from .top_bar import TopBarMixin
from .nav_rail import NavRailMixin
from .rail_metrics import _NAV_MIN_WIDTH
from .tray_manager import TrayManager
from ...state import AppContext
from ...core.task_scheduler import TaskScheduler
from ...ui.cowork_tab import CoworkTab
from ...ui.sidebar import HistorySidebar
from ...ui.structure_graph_view import StructureGraphView
from ...ui.workspace_tab import WorkspaceTab




# Nav rail (sidebar navigation) widths — expanded shows icon+label, collapsed
# shows icon-only (still fully clickable, just narrower).
# The splitter between rail and content draws a drag handle. It only means
# something if the rail can actually take a width from it, so the expanded rail
# is a range rather than one number; long project and thread names in RECENTS
# are the reason someone would widen it.
#
# The ceiling is a SHARE of the window, not a pixel count: 360px is a quarter
# of a 1440 screen and more than a quarter of a 1280 one, where it left the
# seven Kanban lanes 920px of the 1067 they need. A share behaves the same on
# every monitor.
# Where a rail row starts, and how much air sits between its icon and its
# label. The tree rows get these from the style; anything laid out by hand
# beside them has to use the same two numbers or it will not line up.







class MainWindow(NavRailMixin, RailProjectMixin, TopBarMixin,
                 PageRegistryMixin, SessionEventsMixin, QMainWindow):
    #: Biểu tượng khay, hoặc None nếu máy không có khay. Vẫn giữ tên cũ vì
    #: còn vài chỗ đọc thẳng self.tray; bản thân việc dựng/ẩn/thông báo đã
    #: chuyển sang self._tray (TrayManager).
    tray = property(lambda self: self._tray.icon)

    # Nav rows (Dashboard/Schedule/Monitoring are lazy; Workspace is the eager home page).
    _ROW_DASHBOARD, _ROW_SCHEDULE, _ROW_WORKSPACE, _ROW_MONITORING = 0, 1, 2, 3

    def __init__(self, ctx: AppContext, user_name: str = ""):
        super().__init__()
        self.ctx = ctx
        self._user_name = user_name
        self._really_quit = False
        self._life = LifecycleCoordinator(self)
        # Khay hệ thống: presentation/shell/tray_manager.py (R08-T10).
        self._tray = TrayManager(self, icon=app_icon, tooltip=DISPLAY_NAME, tr=tr)
        self._nav_collapsed = False    # icon-only nav rail toggle (Task: collapsible nav)
        self._history_collapsed = False   # remembers History's own collapse-to-strip state
        self.setWindowTitle(f"{DISPLAY_NAME} v{__version__}")
        self.setWindowIcon(app_icon())
        # Fit to the available screen so the window never opens larger than the
        # monitor (auto-fit). Keep a modest minimum that still fits small laptops.
        self._fit_to_screen(1180, 760)

        self.sidebar = HistorySidebar(ctx)
        # Task scheduler ENGINE runs in the background whether or not its Kanban
        # UI (built lazily) is on screen — scheduled tasks must fire regardless.
        self.task_scheduler = TaskScheduler(ctx, parent=self)
        # Desktop notification when a scheduled task finishes; also refresh
        # History — a cowork/code task run saves itself as a new session there.
        self.task_scheduler.task_finished.connect(self._on_scheduled_task_done)
        # NOTE: task_started fires BEFORE the worker thread even begins, so its
        # session doesn't exist on disk yet — refreshing History here would
        # find nothing. history_ready fires once the session is actually
        # saved (right as the run starts, then again after each turn), which
        # is what really makes a Running task's session show up live.
        self.task_scheduler.history_ready.connect(lambda _tid: self._refresh_history())

        # Cowork chat + GraphRAG view are embedded as sub-tabs INSIDE the
        # Workspace screen (per selected project). GraphRAG's heavy
        # QtWebEngine is still built lazily on first display
        # (StructureGraphView._ensure_web).
        self.cowork = CoworkTab(ctx)
        self.structure = StructureGraphView(ctx)
        self.structure.status_message.connect(self.statusBar().showMessage)
        self.cowork.output_changed.connect(self.structure.schedule_rescan)
        self.cowork.status_message.connect(self.statusBar().showMessage)
        # Refresh History (list + running markers + current highlight) whenever a
        # conversation is created/updated or a turn finishes.
        self.cowork.turn_finished.connect(lambda *_: self._refresh_history())
        self.cowork.history_changed.connect(self._refresh_history)
        self.cowork.turn_finished.connect(
            lambda result: self._notify_task(self.cowork, "cowork", result))

        # Workspace screen — the app HOME: project management + the per-project
        # Cowork / GraphRAG sub-tabs and History.
        self.workspace = WorkspaceTab(ctx, cowork=self.cowork, structure=self.structure,
                                      sidebar=self.sidebar)
        self.workspace.status_message.connect(self.statusBar().showMessage)
        self.workspace.projects_changed.connect(self._on_projects_changed)
        self.workspace.open_chat.connect(lambda *_: self._refresh_history())
        self.workspace.new_chat.connect(lambda *_: self._refresh_history())

        # Dashboard + Schedule pages are built lazily on first visit (lazy page
        # creation — keeps startup light); None until then.
        self.dashboard = None
        self.schedule = None
        self.monitoring = None

        # --- right side: top bar + pages (nav rail drives the stack) ---
        right = QWidget()
        right.setObjectName("contentArea")
        rlay = QVBoxLayout(right)
        rlay.setContentsMargins(10, 10, 10, 10)
        rlay.setSpacing(10)
        rlay.addWidget(self._build_topbar())

        self.pages = QStackedWidget()
        # (i18n key, icon, builder-or-None, eager-widget-or-None) — page index == list index
        self._nav_defs = [
            ("app.tab.dashboard", "dashboard", self._build_dashboard, None),
            ("app.tab.schedule", "schedule", self._build_schedule, None),
            ("app.tab.workspace", "workspaces", None, self.workspace),
            ("app.tab.monitoring", "monitoring", self._build_monitoring, None),
        ]
        self._page_widgets = []   # page index → widget (placeholder until lazily built)
        self._built = []
        for _key, _icon_name, _builder, widget in self._nav_defs:
            page = widget if widget is not None else QWidget()
            self.pages.addWidget(page)
            self._page_widgets.append(page)
            self._built.append(widget is not None)

        self._build_nav_rail(right, rlay)
        # Landing stays Workspace ▸ Project, exactly as before. Go through _goto
        # so the page is actually shown — selecting the row alone only moves the
        # highlight (its signals are blocked to avoid rebuild loops).
        self._goto(self._ROW_WORKSPACE, self.workspace.current_subtab())
        self.toast = Toast(self)   # top-left "task done" popup
        # Floating in-app Help assistant — a robot icon pinned bottom-right on
        # every screen; expands into a small help-only chat (see
        # ui/help_agent_widget.py). Managed in Monitoring → Agents Admin.
        from ...ui.help_agent_widget import HelpAgentWidget
        self.help_agent = HelpAgentWidget(ctx, self, user_name=self._user_name)
        self.help_agent.status_message.connect(self.statusBar().showMessage)

        self.statusBar().showMessage(tr("app.status.ready"))
        # Author credit, pinned to the bottom-right corner. A permanent status-bar
        # widget sits at the right end and is never cleared by showMessage (which
        # writes on the left).
        self._credit = QLabel(tr("app.credit"))
        self._credit.setObjectName("faint")
        self._credit.setStyleSheet("padding: 0 10px;")
        self.statusBar().addPermanentWidget(self._credit)
        self._restore_sessions()
        self._tray.setup()
        # Start the task scheduler last, once the whole window exists — it
        # catches up any overdue tasks right away (first tick runs inline).
        self.task_scheduler.start()
        # Auto Model Routing: periodic reassess + pending-switch expiry. Runs
        # background probes only when genuinely due (never a burst at launch).
        try:
            from ...core.routing.scheduler import RoutingScheduler
            self.routing_scheduler = RoutingScheduler(self.ctx, self.ctx.routing(), parent=self)
            self.routing_scheduler.start()
        except Exception:  # noqa: BLE001 — routing must never block app startup
            self.routing_scheduler = None
        on_language_changed(self._retranslate)

    def resizeEvent(self, event):  # noqa: N802 - Qt override
        super().resizeEvent(event)
        # The rail's ceiling is a share of the window, so it moves with the
        # window. Computed once at construction it was read off a not-yet-sized
        # window and stuck at 162px on every monitor.
        if getattr(self, "_nav_wrap", None) is not None and not self._nav_collapsed:
            self._set_nav_width_range(_NAV_MIN_WIDTH, self._nav_max_width())
        # Keep the floating Help assistant pinned to the bottom-right corner.
        if getattr(self, "help_agent", None) is not None:
            self.help_agent.reposition()

    def showEvent(self, event):  # noqa: N802 - Qt override
        super().showEvent(event)
        if getattr(self, "help_agent", None) is not None:
            self._update_dock_guard()
            self.help_agent.reposition()
            self.help_agent.raise_()
        # Build GraphRAG's browser view and first graph once the window is up
        # and idle, so clicking GraphRAG does not sit on an empty view while
        # both happen. 3s is after the first paint and any startup refresh.
        if not getattr(self, "_graph_prewarmed", False):
            self._graph_prewarmed = True
            QTimer.singleShot(3000, self._prewarm_graph)

    def _prewarm_graph(self) -> None:
        view = getattr(self, "structure", None)
        if view is None or not hasattr(view, "prewarm"):
            return
        try:
            view.prewarm()
        except Exception:  # noqa: BLE001 — a warm-up must never break the app
            pass

    # ---- i18n ----------------------------------------------------------
    def _retranslate(self) -> None:
        """Re-apply the current language to this window's own static chrome
        (tabs are the only long-lived text here; the tabs/dialogs retranslate
        themselves)."""
        self._apply_nav_labels()
        self._nav_toggle_btn.setText("" if self._nav_collapsed else tr("app.nav.menu_label"))
        self._nav_toggle_btn.setToolTip(
            tr("app.nav.expand_tooltip") if self._nav_collapsed else tr("app.nav.collapse_tooltip"))
        self._credit.setText(tr("app.credit"))
        if hasattr(self, "provider_lbl"):
            self.provider_lbl.setText(tr("app.provider"))
        if hasattr(self, "settings_btn"):
            self.settings_btn.setText(tr("app.settings"))
        if hasattr(self, "theme_btn"):
            self.theme_btn.setToolTip(tr("settings.theme"))
            for value, act in self._theme_actions.items():
                act.setText(tr(f"settings.theme_{value}"))
        if hasattr(self, "logo_lbl"):
            self.logo_lbl.setText(tr("app.logo"))
        if getattr(self, "help_agent", None) is not None:
            self.help_agent.retranslate()
        self._tray.retranslate()

    # ---- system tray (run in background when the window is closed) ---


    # ---- lazy page building -------------------------------------------



        # Monitoring KEEPS its own tab strip: its eight sub-views live in the
        # page, not in the rail. Workspace is the one that hides its strip,
        # because the rail lists its sub-views directly.


    # ---- flat nav rail -------------------------------------------------





    def _show_window(self) -> None:
        self.showNormal()
        self.raise_()
        self.activateWindow()

    def _quit_app(self) -> None:
        self._really_quit = True
        self.close()


    # ---- top bar -----------------------------------------------------


    _BRAND_LOGO_NAMES = ("fpt_logo.png", "fpt-logo.png", "logo_fpt.png", "fpt_logo.jpg")
    _BRAND_LOGO_HEIGHT = 22


    _THEME_ICONS = {"system": "monitor", "dark": "moon", "light": "sun"}



    # ---- handlers ----------------------------------------------------




    def _update_dock_guard(self) -> None:
        """Keep the floating assistant clear of a screen's own bottom bar.

        Only Cowork has one (the composer). Everywhere else the dock sits in
        the corner as before.
        """
        dock = getattr(self, "help_agent", None)
        if dock is None:
            return
        guard = 0
        on_cowork = (self.pages.currentIndex() == self._ROW_WORKSPACE
                     and self.workspace.current_subtab() == self.workspace._cowork_tab_idx)
        if on_cowork:
            comp = getattr(self.cowork, "composer", None)
            if comp is not None and not comp.isHidden():
                # Measured from the composer's TOP edge in window coordinates:
                # its own height misses the extra row of controls laid out under
                # it, which left the dot still overlapping by ~25px.
                origin = comp.mapTo(self, comp.rect().topLeft())
                # ...but only lift the dot if the composer is actually beneath
                # it. The composer stops at the chat column's right edge, well
                # short of the dot, so lifting it there raised the dot 156px for
                # nothing — on Cowork alone it sat off the corner every other
                # screen keeps it in.
                dock_left = dock.x() - self.mapToGlobal(self.rect().topLeft()).x()
                dock_right = dock_left + dock.width()
                if dock_right > origin.x() and dock_left < origin.x() + comp.width():
                    guard = max(0, self.height() - origin.y() + 8)
        dock.set_bottom_guard(guard)



    # ---- sizing ------------------------------------------------------
    # Share of the available screen the window takes when it has room to. Fixed
    # pixels do not travel: 1180×760 fills a laptop and looks lost on a 4K
    # panel. `want_*` stays the floor so a small screen behaves as before.
    # Canh cửa sổ và tắt sạch: presentation/shell/lifecycle_coordinator.py
    def _fit_to_screen(self, want_w: int, want_h: int) -> None:
        self._life.fit_to_screen(want_w, want_h)

    def _on_screen_maybe_changed(self) -> None:
        if not self._life.screen_maybe_changed():
            return
        if getattr(self, "help_agent", None) is not None:
            self._update_dock_guard()
            self.help_agent.reposition()


    def moveEvent(self, event):  # noqa: N802 - Qt override
        super().moveEvent(event)
        # Dragged to another monitor: its work area (and scaling) may differ, so
        # the floating assistant re-pins and the panes re-decide if they fit.
        self._on_screen_maybe_changed()


    # ---- lifecycle ---------------------------------------------------
    def closeEvent(self, event) -> None:  # noqa: N802
        if self._life.should_keep_running():
            # Chạy nền tiếp: task vẫn chạy và vẫn tự lưu.
            event.ignore()
            self.hide()
            self._tray.show_message(DISPLAY_NAME, tr("app.tray.running_body"), msec=4000)
            return
        # Real quit: stop every running turn (a tab may have several), then close.
        self._life.shutdown()
        self._tray.hide()
        super().closeEvent(event)