#!/usr/bin/env python3
"""Dependency-free offscreen check of the AutoCal window.

Builds the real window with the simulated platform and asserts the invariants
that are easy to break and hard to notice: theme tokens present, layout fitting
inside parents, controls gated by connection and bus state, locales complete.

    python apps/autocal/tools/panel_check.py

No controller, no DLL and no display are needed. Mirrors
``apps/studio/tools/ui_check.py``, but cannot import it: that module pulls in
``orisys_studio`` (the acquisition stack), which AutoCal's environment has none of.
"""

from __future__ import annotations

import os
import sys
from pathlib import Path

APP_ROOT = Path(__file__).resolve().parents[1]
for path in (APP_ROOT / "src", APP_ROOT.parents[1] / "shared" / "src"):
    if str(path) not in sys.path:
        sys.path.insert(0, str(path))

os.environ.setdefault("ORISYS_APP_ID", "autocal")
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
if sys.platform == "win32" and "QT_QPA_FONTDIR" not in os.environ:
    _fonts = Path(os.environ.get("WINDIR", r"C:\Windows")) / "Fonts"
    if _fonts.is_dir():
        os.environ["QT_QPA_FONTDIR"] = str(_fonts)

RESOLUTIONS = ((1440, 900), (1920, 1080))


class Checker:
    """Collects failures instead of asserting, so one run reports everything."""

    def __init__(self) -> None:
        self.failures: list[str] = []
        self.checks = 0

    def that(self, condition: bool, message: str) -> None:
        self.checks += 1
        if not condition:
            self.failures.append(message)

    def report(self) -> int:
        print()
        if self.failures:
            print(f"FAILED — {len(self.failures)} of {self.checks} checks:")
            for failure in self.failures:
                print(f"  - {failure}")
            return 1
        print(f"OK — {self.checks} checks passed")
        return 0


def _visible_descendants(widget):
    for child in widget.findChildren(object):
        if not hasattr(child, "isVisible") or not hasattr(child, "geometry"):
            continue
        if child.isVisible():
            yield child


def main() -> int:
    from PySide6 import __version__ as pyside_version
    from PySide6.QtWidgets import QApplication

    from orisys_app_shared.i18n import set_locale, t
    from orisys_app_shared.theme import build_qss, load_colors

    from orisys_autocal.motion import ConnectionSpec
    from orisys_autocal.ui.axis_panel import COLUMNS
    from orisys_autocal.ui.bus_panel import default_bas_dir
    from orisys_autocal.ui.window import AutoCalMainWindow

    checker = Checker()
    app = QApplication.instance() or QApplication([])
    print(f"Qt binding: PySide6 {pyside_version}")

    # ---- theme tokens -----------------------------------------------------
    for theme in ("dark", "light"):
        colors = load_colors(theme)
        qss = build_qss(theme)
        checker.that(bool(colors), f"{theme}: no colour tokens")
        checker.that(len(qss) > 500, f"{theme}: the stylesheet looks empty")
        checker.that(
            len(build_qss(theme)) == len(qss), f"{theme}: the stylesheet is not stable"
        )

    # ---- locale completeness ---------------------------------------------
    from orisys_autocal.preferences import load_preferences

    prefs = load_preferences()
    for language in ("zh_CN", "en_US"):
        set_locale(language)
        checker.that(t("app.title") != "app.title", f"{language}: app.title missing")
        checker.that(t("axes.title") != "axes.title", f"{language}: axes.title missing")
        checker.that(
            t("bus.state_ok") != "bus.state_ok", f"{language}: bus.state_ok missing"
        )
    set_locale("zh_CN")

    # ---- window ----------------------------------------------------------
    from orisys_autocal.motion import DemoTransport

    for theme in ("dark", "light"):
        window = AutoCalMainWindow(prefs={**prefs, "theme": theme})
        window.poller.service._transport = DemoTransport()  # noqa: SLF001
        app.setStyleSheet(build_qss(theme))
        print(f"\n--- theme={theme} ---")

        for width, height in RESOLUTIONS:
            window.resize(width, height)
            window.show()
            app.processEvents()
            # Every tab, not just the default one: a page that overflows only
            # when its tab is selected is exactly the defect this catches.
            for key in window.workspace.page_keys():
                window.workspace.set_current_key(key)
                app.processEvents()
                oversize = []
                for child in _visible_descendants(window):
                    if _inside_scroll_area(child):
                        continue  # a rail's content is meant to exceed its viewport
                    parent = child.parentWidget()
                    if parent is None or not parent.isVisible():
                        continue
                    geometry = child.geometry()
                    if (
                        geometry.width() > parent.width() + 1
                        or geometry.height() > parent.height() + 1
                    ):
                        oversize.append(
                            f"{type(child).__name__} {geometry.width()}x{geometry.height()}"
                            f" > {parent.width()}x{parent.height()}"
                        )
                checker.that(
                    not oversize, f"{theme} {width}x{height} tab={key}: {oversize}"
                )
            window.workspace.set_current_key("axes")
            print(f"  {width}x{height}: every tab fits")

        # ---- the permanent shell ----------------------------------------
        checker.that(
            window.workspace.page_keys()
            == ["axes", "sequence", "finger", "sensor", "surface", "points"],
            f"unexpected tab set: {window.workspace.page_keys()}",
        )
        checker.that(
            window.status_strip.isVisible(),
            "the motion status strip is not visible",
        )
        checker.that(
            window.status_strip.height() <= 48,
            f"the status strip is {window.status_strip.height()}px tall",
        )
        for key in window.workspace.page_keys():
            window.workspace.set_current_key(key)
            app.processEvents()
            checker.that(
                window.status_strip.isVisible(),
                f"the status strip vanished on tab {key}",
            )
            checker.that(
                bool(window.workspace.tabText(window.workspace.currentIndex())),
                f"tab {key} has no label",
            )
        window.workspace.set_current_key("axes")

        # The readout rail must show all five drives without scrolling.
        readout_rows = len(window.axis_readout._rows)
        checker.that(readout_rows == 5, f"the readout rail shows {readout_rows} axes")
        checker.that(
            window.axis_readout.width() >= 200,
            f"the readout rail is only {window.axis_readout.width()}px wide",
        )

        # The sequence tab: three zones, a persisted profile, and a point list
        # whose coordinates are generated rather than typed.
        sequence = window.sequence_panel
        checker.that(
            sequence.profile_keys()
            == [
                "mode",
                "pitch_mm",
                "margin_mm",
                "radius_mm",
                "clear_height_mm",
                "approach_speed_mm_s",
                "press_speed_mm_s",
                "press_depth_mm",
                "dwell_s",
                "settle_window_s",
                "repeats",
                "order",
            ],
            f"sequence profile fields changed: {sequence.profile_keys()}",
        )
        checker.that(
            sequence.validation_checks()
            == ["on_surface", "within_travel", "contact_confirmable"],
            f"sequence validation checks changed: {sequence.validation_checks()}",
        )
        for name, phase in sequence.pending_phases().items():
            button = sequence._pending_buttons[name]
            checker.that(
                not button.isEnabled() and phase in button.toolTip(),
                f"sequence control {name} is usable or does not name its phase",
            )
        checker.that(
            sequence.planned_steps() == [],
            "the sequence tab handed out steps a runner could start",
        )
        checker.that(
            sequence.point_row_count() > 0,
            "the sequence point list is empty",
        )
        checker.that(
            sequence.table.columnCount() == len(sequence.column_keys()),
            f"the point list has {sequence.table.columnCount()} columns, expected {len(sequence.column_keys())}",
        )

        # The shell: one rail, a run bar, and a health chip.
        checker.that(
            window.main_splitter.count() == 2,
            f"the layout has {window.main_splitter.count()} columns, expected 2",
        )
        checker.that(
            window.left_rail.widget() is window.rail_content,
            "the setup rail is not scrollable",
        )
        checker.that(
            window.run_bar.isVisible(),
            "the run bar is not visible",
        )
        checker.that(
            not window.run_bar.abort_button.isEnabled(),
            "abort is enabled with no run in progress",
        )
        for key in window.workspace.page_keys():
            window.workspace.set_current_key(key)
            app.processEvents()
            checker.that(
                window.run_bar.isVisible(),
                f"the run bar vanished on tab {key}",
            )
        window.workspace.set_current_key("axes")
        checker.that(
            bool(window.status_strip.chip_health.text()),
            "the poll-health chip has no text",
        )
        checker.that(
            "QStatusBar" in window.statusBar().styleSheet(),
            "the status bar is not using its own theme token",
        )

        # A collapsed bus-data group must not cost the page any height.
        checker.that(
            not window.bus_data_panel.isVisible(),
            "the bus-data panel is expanded by default",
        )
        print("  shell: strip, readout rail and sequence profile verified")

        panel = window.axis_panel
        checker.that(panel.axis_count == 5, "the platform is not five axes")
        checker.that(
            panel.table.columnCount() == len(COLUMNS) + 1,
            "the axis table lost a column",
        )
        # Every header must fit its column: a clipped header is how a table stops
        # being readable without anyone noticing.
        for index in range(panel.table.columnCount()):
            header = panel.table.horizontalHeaderItem(index).text()
            width = panel.table.columnWidth(index)
            needed = panel.table.fontMetrics().horizontalAdvance(header) + 12
            checker.that(
                width >= needed,
                f"axis column {index} ({header!r}) is {width}px, needs {needed}px",
            )
        checker.that(
            len(COLUMNS) == 7,
            f"the axis table should show seven data columns, has {len(COLUMNS)}",
        )
        checker.that(
            window.axis_panel._detail_label.text(),
            "the selected-axis detail line is empty",
        )
        headers = [
            panel.table.horizontalHeaderItem(index).text()
            for index in range(panel.table.columnCount())
        ]
        checker.that(
            all(headers) and headers[0] == t("axes.axis"),
            f"axis table headers are not localised: {headers}",
        )
        checker.that(
            all(
                panel.table.item(row, 0) is not None for row in range(panel.axis_count)
            ),
            "an axis row has no data cell",
        )

        # Motion must be unreachable before a bus is initialised.
        checker.that(
            not panel._rows[0]["fwd_button"].isEnabled(),
            "jog is enabled before the bus is initialised",
        )

        # Bus data follows the reported bus family. ``isEnabledTo`` rather than
        # ``isEnabled``: the panel now lives in a collapsed group, and Qt reports
        # a hidden ancestor as disabling everything inside it.
        box = window.bus_data_group
        window.bus_data_panel.set_connected(True)
        window.bus_data_panel.set_bus_type("ecat")
        checker.that(
            window.bus_data_panel.ecat_box.isEnabledTo(box)
            and not window.bus_data_panel.rtex_box.isEnabledTo(box),
            "the SDO/RTEX panels are not gated by bus type",
        )

        # Expanding the group must reveal the panel, not resize the page.
        before = window.size()
        box.setChecked(True)
        app.processEvents()
        checker.that(
            window.bus_data_panel.isVisible(), "expanding the group did not show the panel"
        )
        box.setChecked(False)
        app.processEvents()
        checker.that(
            window.size() == before, "toggling bus data resized the window"
        )

        # A full simulated session: connect, initialise from the shipped BAS.
        window.connect_controller(ConnectionSpec(mode="demo"), label="connect")
        _wait_for(app, lambda: window._last_snapshot.connected, 6.0)
        checker.that(
            window._last_snapshot.connected, "the simulated controller did not connect"
        )

        window.bus_panel.set_bas_path(str(default_bas_dir() / "ECAT.bas"))
        window._on_download_bas()
        ok = _wait_for(app, lambda: window._last_snapshot.bus.init_status == 1, 8.0)
        checker.that(ok, "the simulated bus did not report initialised")
        if ok:
            checker.that(
                window._last_snapshot.bus.bus_type == "ecat",
                "the bus type was not decoded from BUS_TYPE",
            )
            checker.that(
                window._last_snapshot.bus.total_axes == 5,
                "the bus did not report five axes",
            )
            checker.that(
                panel._rows[0]["fwd_button"].isEnabled(),
                "jog stayed disabled after the bus was initialised",
            )
            checker.that(
                "65" in window.axis_panel._detail_label.text(),
                "ATYPE was not read back on the detail line (expected 65, position mode)",
            )
            print(
                f"  session: bus={window._last_snapshot.bus.bus_type} "
                f"axes={window._last_snapshot.bus.total_axes} "
                f"{panel.enabled_count_label.text()}"
            )
            # The strip must be reporting the live session, from whatever tab.
            window.workspace.set_current_key("surface")
            app.processEvents()
            strip = window.status_strip
            checker.that(
                strip.chip_connection.text() == t("connection.state_open"),
                f"strip connection chip says {strip.chip_connection.text()!r}",
            )
            checker.that(
                strip.chip_bus.text() == t("bus.type_ecat"),
                f"strip bus chip says {strip.chip_bus.text()!r}",
            )
            checker.that(
                strip.chip_init.text() == t("bus.state_ok"),
                f"strip init chip says {strip.chip_init.text()!r}",
            )
            checker.that(
                t("axes.enabled_count", on=5, total=5) == strip.chip_axes.text()
                or "5" in strip.chip_axes.text(),
                f"strip axis chip says {strip.chip_axes.text()!r}",
            )
            checker.that(
                window.axis_readout._rows[0]["position"].text().startswith("0.000"),
                f"readout row 0 shows {window.axis_readout._rows[0]['position'].text()!r}",
            )
            window.workspace.set_current_key("axes")

        window.close()
        app.processEvents()

    return checker.report()


def _inside_scroll_area(widget) -> bool:
    """Whether ``widget`` is scroll-area content rather than a laid-out child."""
    from PySide6.QtWidgets import QAbstractScrollArea

    parent = widget.parentWidget()
    while parent is not None:
        if isinstance(parent, QAbstractScrollArea):
            return True
        parent = parent.parentWidget()
    return False


def _wait_for(app, predicate, timeout: float) -> bool:
    import time

    deadline = time.monotonic() + timeout
    while time.monotonic() < deadline:
        app.processEvents()
        if predicate():
            return True
        time.sleep(0.02)
    return False


if __name__ == "__main__":
    raise SystemExit(main())