path: root/ui/main_window.py

"""
ui/main_window.py

Toolbar sections (left→right):
  [▶ RUN]  [⬤ LOG]  |  [⚙ DEVICES]  |  [⚗ SIGNALS]  |  [📐 PLOT]  |  [⚙ SETTINGS]
                                                                        spacer  |  timer

Central:
  Left: ControlPanel (output widgets only)
  Center: StripChartWidget

All secondary features live in floating windows.
"""

from PyQt6.QtWidgets import (
    QMainWindow, QWidget, QHBoxLayout, QVBoxLayout,
    QSplitter, QStatusBar, QLabel, QPushButton,
    QToolBar, QSizePolicy, QApplication,
)
from PyQt6.QtCore import Qt, QTimer, pyqtSlot
import os

from devices.analog_input    import AnalogInputDevice
from devices.digital_io      import DigitalIODevice
from devices.serial_device   import SerialDevice
from devices.device_registry import DeviceRegistry
from core.acquisition        import AcquisitionEngine
from core.signal_processor   import SignalProcessor

from ui.control_panel                import ControlPanel
from ui.strip_chart                  import StripChartWidget
from ui.windows.devices_window  import DevicesWindow
from ui.windows.signals_window  import SignalsWindow
from ui.windows.plot_window     import PlotWindow, build_default_layout
from ui.windows.settings_window import SettingsWindow


_DARK_QSS  = os.path.join(os.path.dirname(os.path.abspath(__file__)), "style_dark.qss")
_LIGHT_QSS = os.path.join(os.path.dirname(os.path.abspath(__file__)), "style_light.qss")


class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("LabDAQ")
        self.setMinimumSize(1000, 640)

        self.registry  = DeviceRegistry()
        self.engine    = AcquisitionEngine(poll_interval_ms=100)
        self.processor = SignalProcessor()
        self._settings = dict(SettingsWindow._defaults)

        self._elapsed = 0
        self._win_devices  = None
        self._win_signals  = None
        self._win_plot     = None
        self._win_settings = None

        self._init_demo_devices()
        self._build_ui()
        self._connect_signals()

    # ── Demo ──────────────────────────────────────────────────────────────

    def _init_demo_devices(self):
        for dev in [
            AnalogInputDevice(device_id="ai_0",  num_channels=4, simulate=True, backend="nidaqmx"),
            AnalogInputDevice(device_id="ard_0", num_channels=4, simulate=True, backend="arduino"),
            DigitalIODevice  (device_id="dio_0", num_inputs=4, num_outputs=4, simulate=True),
            SerialDevice     (device_id="ser_0", num_channels=3, simulate=True),
        ]:
            dev.connect()
            self.registry.add_instance(dev)
            self.engine.add_device(dev)

    # ── UI ────────────────────────────────────────────────────────────────

    def _build_ui(self):
        # ── Toolbar ──────────────────────────────────────────────────────
        tb = QToolBar(); tb.setObjectName("mainToolbar"); tb.setMovable(False)
        self.addToolBar(tb)

        def _sep():
            s = QFrame(); s.setFrameShape(QFrame.Shape.VLine)
            s.setObjectName("toolbarSep"); return s

        # RUN / LOG
        self._run_btn = QPushButton("▶  RUN")
        self._run_btn.setObjectName("runButton"); self._run_btn.setCheckable(True)
        self._run_btn.clicked.connect(self._toggle_run); tb.addWidget(self._run_btn)

        self._log_btn = QPushButton("⬤  LOG")
        self._log_btn.setObjectName("logButton"); self._log_btn.setCheckable(True)
        self._log_btn.setEnabled(False); self._log_btn.clicked.connect(self._toggle_log)
        tb.addWidget(self._log_btn)

        tb.addWidget(_sep())

        # DEVICES
        dev_btn = QPushButton("⊞  Devices")
        dev_btn.setObjectName("toolbarSectionBtn")
        dev_btn.setCheckable(True)
        dev_btn.clicked.connect(lambda c: self._toggle_win("devices", c, dev_btn))
        tb.addWidget(dev_btn); self._btn_devices = dev_btn

        tb.addWidget(_sep())

        # SIGNALS
        sig_btn = QPushButton("⚗  Signals")
        sig_btn.setObjectName("toolbarSectionBtn")
        sig_btn.setCheckable(True)
        sig_btn.clicked.connect(lambda c: self._toggle_win("signals", c, sig_btn))
        tb.addWidget(sig_btn); self._btn_signals = sig_btn

        tb.addWidget(_sep())

        # PLOT
        plot_btn = QPushButton("📐  Plot")
        plot_btn.setObjectName("toolbarSectionBtn")
        plot_btn.setCheckable(True)
        plot_btn.clicked.connect(lambda c: self._toggle_win("plot", c, plot_btn))
        tb.addWidget(plot_btn); self._btn_plot = plot_btn

        tb.addWidget(_sep())

        # SETTINGS
        set_btn = QPushButton("⚙  Settings")
        set_btn.setObjectName("toolbarSectionBtn")
        set_btn.setCheckable(True)
        set_btn.clicked.connect(lambda c: self._toggle_win("settings", c, set_btn))
        tb.addWidget(set_btn); self._btn_settings = set_btn

        spacer = QWidget(); spacer.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Preferred)
        tb.addWidget(spacer)

        self._time_lbl = QLabel("00:00:00"); self._time_lbl.setObjectName("timeLabel")
        tb.addWidget(self._time_lbl)

        # ── Central ───────────────────────────────────────────────────────
        central = QWidget(); self.setCentralWidget(central)
        root = QHBoxLayout(central); root.setContentsMargins(0,0,0,0); root.setSpacing(0)

        hsplit = QSplitter(Qt.Orientation.Horizontal); hsplit.setHandleWidth(3)

        self._ctrl = ControlPanel(self.registry)
        self._ctrl.setMinimumWidth(200); self._ctrl.setMaximumWidth(320)
        hsplit.addWidget(self._ctrl)

        self._chart = StripChartWidget(self.engine, self.registry, self.processor)
        hsplit.addWidget(self._chart)

        hsplit.setSizes([240, 1000])
        root.addWidget(hsplit)

        # ── Status bar ─────────────────────────────────────────────────
        sb = QStatusBar(); self.setStatusBar(sb)
        self._status = QLabel("Ready"); sb.addWidget(self._status)
        self._log_lbl = QLabel(""); sb.addPermanentWidget(self._log_lbl)

        self._clock = QTimer(self); self._clock.setInterval(1000)
        self._clock.timeout.connect(self._tick)

    def _connect_signals(self):
        self.engine.new_data.connect(self.processor.on_raw_data)
        self.processor.processed_data.connect(self._chart.on_new_data)
        self.engine.log_started.connect(lambda p: self._log_lbl.setText(f"● {p}"))
        self.engine.log_stopped.connect(lambda p: self._log_lbl.setText(f"✓ {p}"))

    # ── Window management ─────────────────────────────────────────────────

    def _toggle_win(self, name: str, checked: bool, btn: QPushButton):
        creators = {
            "devices":  self._open_devices,
            "signals":  self._open_signals,
            "plot":     self._open_plot,
            "settings": self._open_settings,
        }
        wins = {
            "devices":  "_win_devices",
            "signals":  "_win_signals",
            "plot":     "_win_plot",
            "settings": "_win_settings",
        }
        if checked:
            creators[name]()
        else:
            win = getattr(self, wins[name], None)
            if win: win.hide()

    def _open_devices(self):
        if self._win_devices is None:
            self._win_devices = DevicesWindow(self.registry, self.engine, self)
            self._win_devices.device_added.connect(self._on_device_added)
            self._win_devices.device_removed.connect(self._on_device_removed)
            self._win_devices.device_reconfigured.connect(self._on_device_reconfigured)
            self._win_devices.closed.connect(lambda: self._btn_devices.setChecked(False))
        self._show_win(self._win_devices, "right")

    def _open_signals(self):
        if self._win_signals is None:
            self._win_signals = SignalsWindow(self.registry, self.processor, self)
            self._win_signals.derived_changed.connect(self._on_derived_changed)
            self._win_signals.visibility_changed.connect(self._chart.refresh)
            self._win_signals.closed.connect(lambda: self._btn_signals.setChecked(False))
        self._show_win(self._win_signals, "right")

    def _open_plot(self):
        if self._win_plot is None:
            self._win_plot = PlotWindow(self.registry, self.processor,
                                        self._chart._cfg, self)
            self._win_plot.layout_applied.connect(self._chart.apply_layout)
            self._win_plot.closed.connect(lambda: self._btn_plot.setChecked(False))
        else:
            self._win_plot.cfg = self._chart._cfg
            self._win_plot._populate()
        self._show_win(self._win_plot, "below")

    def _open_settings(self):
        if self._win_settings is None:
            self._win_settings = SettingsWindow(self.registry, self.engine,
                                                 self._settings, self)
            self._win_settings.theme_changed.connect(self._apply_theme)
            self._win_settings.settings_changed.connect(self._on_settings)
            self._win_settings.closed.connect(lambda: self._btn_settings.setChecked(False))
        self._show_win(self._win_settings, "right")

    def _show_win(self, win: QWidget, position: str = "right"):
        geo = self.geometry()
        if not win.isVisible():
            if position == "right":
                win.move(geo.right() + 8, geo.top() + 40)
            elif position == "below":
                win.move(geo.left(), geo.bottom() + 8)
        win.show(); win.raise_(); win.activateWindow()

    # ── Device/signal events ──────────────────────────────────────────────

    def _on_device_added(self):
        self._chart.refresh()
        if self._win_plot: self._win_plot.refresh_channels()
        self._status.setText("Device added.")

    def _on_device_removed(self, dev_id: str):
        self._chart.refresh()
        self._status.setText(f"Device '{dev_id}' removed.")

    def _on_device_reconfigured(self, dev_id: str):
        """Called after Configure dialog closes — rebuild chart curves."""
        self._chart.refresh()
        if self._win_plot:
            self._win_plot.refresh_channels()
        self._status.setText(f"Device '{dev_id}' reconfigured.")

    def _on_derived_changed(self):
        self._chart.refresh()
        if self._win_plot: self._win_plot.refresh_channels()

    # ── Run / Log ─────────────────────────────────────────────────────────

    def _toggle_run(self, c: bool):
        if c:
            self.engine.start()
            self._run_btn.setText("⏹  STOP"); self._log_btn.setEnabled(True)
            self._clock.start(); self._status.setText("Acquiring…")
        else:
            self.engine.stop()
            self._run_btn.setText("▶  RUN")
            if self._log_btn.isChecked(): self._log_btn.setChecked(False)
            self._log_btn.setEnabled(False); self._clock.stop()
            self._status.setText("Stopped")

    def _toggle_log(self, c: bool):
        if c:
            os.makedirs(self._settings.get("log_dir","logs"), exist_ok=True)
            p = self.engine.start_logging(
                os.path.join(self._settings.get("log_dir","logs"), ""))
            self._log_btn.setText("⏹  LOGGING")
            self._status.setText(f"Logging → {p}")
        else:
            self.engine.stop_logging(); self._log_btn.setText("⬤  LOG")

    # ── Settings ──────────────────────────────────────────────────────────

    def _apply_theme(self, theme: str):
        qss_file = _DARK_QSS if theme == "dark" else _LIGHT_QSS
        if os.path.exists(qss_file):
            with open(qss_file) as f:
                QApplication.instance().setStyleSheet(f.read())
        # Update pyqtgraph plot colours independently of QSS
        self._chart.set_theme(theme)

    def _on_settings(self, cfg: dict):
        self._settings.update(cfg)
        self.engine._interval = cfg.get("poll_ms", 100) / 1000.0

    def _tick(self):
        self._elapsed += 1
        h=self._elapsed//3600; m=(self._elapsed%3600)//60; s=self._elapsed%60
        self._time_lbl.setText(f"{h:02d}:{m:02d}:{s:02d}")

    def closeEvent(self, event):
        for w in (self._win_devices,self._win_signals,self._win_plot,self._win_settings):
            if w: w.close()
        self.engine.stop(); event.accept()


from PyQt6.QtWidgets import QFrame