path: root/ui/windows/config_window.py

"""
ui/windows/config_window.py

Unified Configuration window — Devices | Channels | Plot in one tabbed window.

Devices tab layout (2 columns):
  Left  — physical devices (add/configure/remove)
  Right — signal table (Device / Signal ID / Dir / On / Label / Unit / Min / Max)

Channels tab layout (2 columns):
  Left  — Namespace browser (Signals / Channels / vars, ui/namespace_panel.py
           — plain read-only reference, reused as-is for the dockable
           Namespace panel on the main window too) plus a "Create Channel"
           button below it, local to this tab only: uses whichever rows are
           selected (multi-select) as the new Channel's sources, or creates
           an empty Channel if nothing's selected. See _on_create_channel_
           clicked().
  Right — derived / virtual channels — operations (filters/calibration/math/script)
           are configured per Channel here, not on the Signals side.
"""

from __future__ import annotations
from copy import deepcopy
from typing import List, Optional, Set, Tuple

from PyQt6.QtWidgets import (
    QWidget, QVBoxLayout, QHBoxLayout, QLabel, QPushButton,
    QScrollArea, QFrame, QTabWidget, QTableWidget, QTableWidgetItem,
    QHeaderView, QCheckBox, QMessageBox, QAbstractItemView, QSplitter,
    QDoubleSpinBox,
)
from PyQt6.QtCore import Qt, pyqtSignal, QTimer
from PyQt6.QtGui import QCloseEvent, QColor, QShowEvent

from devices.device_registry import DeviceRegistry
from core.acquisition import AcquisitionEngine
from core.signal_processor import SignalProcessor, Channel

from ui.windows.devices_window import DeviceRow, SignalsTab
from ui.windows.channels_window import PipelineTab, _slug_id, _dedupe_name
from ui.windows.plot_window import (
    PlotWindow, LayoutConfig, LayoutCanvas, PaneBlock,
    build_default_layout, _DragReorderContainer,
)
from ui.namespace_panel import NamespacePanel


# ══════════════════════════════════════════════════════════════════════════════
#  Enhanced signals table — adds Dir badge and pipeline ⚙ button
# ══════════════════════════════════════════════════════════════════════════════

class _SignalsTab(SignalsTab):
    """SignalsTab with a Dir (READ/WRITE) badge. Operations (filters/calibration/math)
    are configured per Channel in the Channels pane, not here."""

    _C_DEVICE  = 0
    _C_CH_ID   = 1
    _C_DIR     = 2
    _C_ENABLED = 3
    _C_NAME    = 4
    _C_UNIT    = 5
    _C_MIN     = 6
    _C_MAX     = 7

    channel_renamed = pyqtSignal(str, str, str, str)  # old_dev, old_id, new_dev, new_id

    def _build(self):
        lay = QVBoxLayout(self)
        lay.setContentsMargins(0, 0, 0, 0)

        self._table = QTableWidget()
        self._table.setObjectName("channelTable")
        self._table.setColumnCount(8)
        self._table.setHorizontalHeaderLabels(
            ["Device", "Signal ID", "Dir", "On", "Label", "Unit", "Min", "Max"]
        )
        name_hdr_item = self._table.horizontalHeaderItem(self._C_NAME)
        if name_hdr_item is not None:
            name_hdr_item.setToolTip(
                "Technical label only — for the profile-facing name, create a Channel "
                "in the Channels window."
            )
        hdr = self._table.horizontalHeader()
        hdr.setSectionResizeMode(self._C_NAME,    QHeaderView.ResizeMode.Stretch)
        hdr.setSectionResizeMode(self._C_DEVICE,  QHeaderView.ResizeMode.ResizeToContents)
        hdr.setSectionResizeMode(self._C_CH_ID,   QHeaderView.ResizeMode.ResizeToContents)
        hdr.setSectionResizeMode(self._C_DIR,     QHeaderView.ResizeMode.ResizeToContents)
        hdr.setSectionResizeMode(self._C_ENABLED, QHeaderView.ResizeMode.ResizeToContents)
        self._table.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
        self._table.setAlternatingRowColors(True)
        self._table.verticalHeader().setVisible(False)
        self._table.cellChanged.connect(self._on_cell_changed)
        lay.addWidget(self._table)

    def refresh(self):
        self._table.blockSignals(True)
        self._table.setRowCount(0)
        row = 0
        for dev in self.registry.all_instances():
            for ch in dev.info.signals:
                self._table.insertRow(row)

                dev_item = QTableWidgetItem(f"{dev.info.icon} {dev.info.device_id}")
                dev_item.setFlags(dev_item.flags() & ~Qt.ItemFlag.ItemIsEditable)
                dev_item.setForeground(QColor("#64748b"))
                self._table.setItem(row, self._C_DEVICE, dev_item)

                ch_item = QTableWidgetItem(ch.signal_id)
                ch_item.setData(Qt.ItemDataRole.UserRole, (dev.info.device_id, ch.signal_id))
                ch_item.setForeground(QColor(ch.color))
                self._table.setItem(row, self._C_CH_ID, ch_item)

                is_out = getattr(ch, "writable", False)
                dir_item = QTableWidgetItem("WRITE" if is_out else "READ")
                dir_item.setFlags(dir_item.flags() & ~Qt.ItemFlag.ItemIsEditable)
                dir_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
                dir_item.setForeground(QColor("#f59e0b") if is_out else QColor("#22c55e"))
                self._table.setItem(row, self._C_DIR, dir_item)

                # Enable toggle — disabled for output channels
                chk_w = QWidget()
                chk_l = QHBoxLayout(chk_w)
                chk_l.setContentsMargins(0, 0, 0, 0)
                chk_l.setAlignment(Qt.AlignmentFlag.AlignCenter)
                chk = QCheckBox()
                chk.setChecked(True if is_out else ch.enabled)
                if is_out:
                    chk.setEnabled(False)
                else:
                    dev_id_cap = dev.info.device_id
                    ch_id_cap  = ch.signal_id
                    chk.toggled.connect(
                        lambda checked, d=dev_id_cap, c=ch_id_cap:
                            self._on_enabled(d, c, checked)
                    )
                chk_l.addWidget(chk)
                self._table.setCellWidget(row, self._C_ENABLED, chk_w)

                name_item = QTableWidgetItem(ch.name)
                name_item.setData(Qt.ItemDataRole.UserRole, (dev.info.device_id, ch.signal_id))
                self._table.setItem(row, self._C_NAME, name_item)

                self._table.setItem(row, self._C_UNIT, QTableWidgetItem(ch.unit))
                self._table.setItem(row, self._C_MIN,  QTableWidgetItem(str(ch.min_value)))
                self._table.setItem(row, self._C_MAX,  QTableWidgetItem(str(ch.max_value)))

                row += 1

        self._table.blockSignals(False)

    def _on_cell_changed(self, row: int, col: int):
        if col == self._C_CH_ID:
            self._on_id_edited(row)
            return
        super()._on_cell_changed(row, col)

    def _on_id_edited(self, row: int):
        """Signal IDs are stable/backend-facing by default (see
        devices/base_device.py::SignalConfig) but user-editable here, same
        as a derived Channel's ID — renaming propagates through
        reference_registry.propagate_rename() (wired via channel_renamed)
        so plot traces / controls / pipelines pointing at the old id follow
        it instead of going dangling (the bug that motivated this feature:
        an Arduino analog pin remap used to change the id outright)."""
        id_item = self._table.item(row, self._C_CH_ID)
        if id_item is None:
            return
        ref = id_item.data(Qt.ItemDataRole.UserRole)
        if ref is None:
            return
        dev_id, old_id = ref
        new_id = id_item.text().strip()
        if not new_id or new_id == old_id:
            self._table.blockSignals(True)
            id_item.setText(old_id)
            self._table.blockSignals(False)
            return
        dev = self.registry.get_instance(dev_id)
        if not dev or any(s.signal_id == new_id for s in dev.info.signals if s.signal_id != old_id):
            self._table.blockSignals(True)
            id_item.setText(old_id)
            self._table.blockSignals(False)
            return
        ch = dev.get_signal(old_id)
        if not ch:
            return
        ch.signal_id = new_id
        id_item.setData(Qt.ItemDataRole.UserRole, (dev_id, new_id))
        name_item = self._table.item(row, self._C_NAME)
        if name_item is not None:
            name_item.setData(Qt.ItemDataRole.UserRole, (dev_id, new_id))
        self.channel_renamed.emit(dev_id, old_id, dev_id, new_id)


# ══════════════════════════════════════════════════════════════════════════════
#  Plot tab — PlotWindow embedded without floating chrome
# ══════════════════════════════════════════════════════════════════════════════

class _PlotTab(PlotWindow):
    def __init__(self, registry: DeviceRegistry, processor: SignalProcessor,
                 current: Optional[LayoutConfig] = None, parent=None):
        QWidget.__init__(self, parent)
        self.registry  = registry
        self.processor = processor
        self.cfg       = deepcopy(current) if current else build_default_layout(registry, processor)
        self._blocks: List[PaneBlock] = []
        self._build()
        self._populate()

    def _build(self):
        root = QVBoxLayout(self); root.setContentsMargins(0, 0, 0, 0); root.setSpacing(0)

        glob = QWidget(); glob.setObjectName("cfgGlobalBar")
        gl   = QHBoxLayout(glob); gl.setContentsMargins(12, 7, 12, 7); gl.setSpacing(12)
        gl.addWidget(QLabel("Window:"))
        self._win = QDoubleSpinBox(); self._win.setRange(1, 3600)
        self._win.setSuffix(" s"); self._win.setValue(self.cfg.time_window_s)
        self._win.setObjectName("cfgGlobalSpin")
        self._win.valueChanged.connect(lambda v: setattr(self.cfg, "time_window_s", v))
        gl.addWidget(self._win)
        self._linkx = QCheckBox("Link X"); self._linkx.setChecked(self.cfg.link_x)
        self._linkx.setObjectName("cfgLiveChk")
        self._linkx.toggled.connect(lambda v: setattr(self.cfg, "link_x", v))
        gl.addWidget(self._linkx)
        self._legend = QCheckBox("Legend"); self._legend.setChecked(self.cfg.show_legend)
        self._legend.setObjectName("cfgLiveChk")
        self._legend.toggled.connect(lambda v: setattr(self.cfg, "show_legend", v))
        gl.addWidget(self._legend)
        self._live = QCheckBox("Live preview"); self._live.setObjectName("cfgLiveChk")
        gl.addWidget(self._live)
        gl.addStretch()
        add_btn = QPushButton("＋  Add Pane"); add_btn.setObjectName("addDeviceButton")
        add_btn.clicked.connect(self._add_pane); gl.addWidget(add_btn)
        root.addWidget(glob)

        canvas_bar = QWidget(); canvas_bar.setObjectName("layoutCanvasBar")
        cb_lay = QVBoxLayout(canvas_bar)
        cb_lay.setContentsMargins(10, 6, 10, 8); cb_lay.setSpacing(4)
        clbl = QLabel(
            "LAYOUT  —  edge: split (blue)  |  "
            "edge gap: insert between (amber)  |  center: move (green)"
        )
        clbl.setObjectName("layoutCanvasLabel")
        cb_lay.addWidget(clbl)
        self._canvas = LayoutCanvas(self.cfg.panes, self.cfg.tree, self)
        self._canvas._cfg_ref = self.cfg
        self._canvas.arrangement_changed.connect(self._maybe_live)
        cb_lay.addWidget(self._canvas)
        root.addWidget(canvas_bar)

        div = QFrame(); div.setFrameShape(QFrame.Shape.HLine)
        div.setObjectName("devWindowDivider"); root.addWidget(div)

        scroll = QScrollArea(); scroll.setWidgetResizable(True)
        scroll.setObjectName("deviceScroll")
        self._cont = _DragReorderContainer(self)
        self._blay = QVBoxLayout(self._cont)
        self._blay.setContentsMargins(10, 10, 10, 10); self._blay.setSpacing(12)
        self._blay.addStretch()
        scroll.setWidget(self._cont)
        root.addWidget(scroll, 1)

        btm = QWidget(); btm.setObjectName("cfgBottomBar")
        bl  = QHBoxLayout(btm); bl.setContentsMargins(12, 8, 12, 8)
        for lbl, fn in [("⟳  Rebuild from Channels", self._reset),
                        ("↓  Export JSON", self._export),
                        ("↑  Import JSON", self._import_json)]:
            b = QPushButton(lbl); b.setObjectName("configButton")
            b.clicked.connect(fn); bl.addWidget(b)
        bl.addStretch()
        ap = QPushButton("✓  Apply"); ap.setObjectName("applyButton")
        ap.clicked.connect(self._apply); bl.addWidget(ap)
        root.addWidget(btm)


# ══════════════════════════════════════════════════════════════════════════════
#  ConfigWindow
# ══════════════════════════════════════════════════════════════════════════════

class ConfigWindow(QWidget):
    device_added               = pyqtSignal()
    device_removed             = pyqtSignal(str)
    device_reconfigured        = pyqtSignal(str)
    channel_visibility_changed = pyqtSignal(str, str, bool)
    channel_name_changed       = pyqtSignal(str, str, str)
    channel_unit_changed       = pyqtSignal(str, str, str)
    pipeline_changed           = pyqtSignal()
    derived_changed            = pyqtSignal()
    channel_renamed            = pyqtSignal(str, str, str, str)  # old_dev, old_id, new_dev, new_id
    layout_applied             = pyqtSignal(object)
    closed                     = pyqtSignal()

    def __init__(self, registry: DeviceRegistry, engine: AcquisitionEngine,
                 processor: SignalProcessor,
                 current_layout: Optional[LayoutConfig] = None, parent=None):
        super().__init__(parent, Qt.WindowType.Window)
        self.registry  = registry
        self.engine    = engine
        self.processor = processor
        self._dev_rows: dict = {}

        self.setWindowTitle("Configuration")
        self.setMinimumSize(900, 580)
        self.resize(1200, 760)
        self._build(current_layout)

    # ── Build ────────────────────────────────────────────────────────────────

    def _build(self, current_layout: Optional[LayoutConfig]):
        root = QVBoxLayout(self); root.setContentsMargins(0, 0, 0, 0); root.setSpacing(0)
        self.tabs = QTabWidget()
        self.tabs.setObjectName("signalBuilderTabs")
        root.addWidget(self.tabs, 1)
        self._build_devices_tab()
        self._build_channels_tab()
        self._build_plot_tab(current_layout)
        self.tabs.currentChanged.connect(self._on_tab_changed)

    # ── Tab 0: Devices ───────────────────────────────────────────────────────
    # Left  — physical devices (add/configure/remove)
    # Right — signal table (metadata + enable)

    def _build_devices_tab(self):
        w = QWidget()
        lay = QVBoxLayout(w); lay.setContentsMargins(0, 0, 0, 0); lay.setSpacing(0)

        splitter = QSplitter(Qt.Orientation.Horizontal)
        splitter.setObjectName("deviceSplitter")
        lay.addWidget(splitter, 1)

        # Left: physical devices
        dev_w = QWidget()
        dev_l = QVBoxLayout(dev_w); dev_l.setContentsMargins(0, 0, 0, 0); dev_l.setSpacing(0)

        bar = QWidget(); bar.setObjectName("cfgGlobalBar")
        bl  = QHBoxLayout(bar); bl.setContentsMargins(10, 7, 10, 7); bl.setSpacing(6)
        lbl = QLabel("Physical Devices"); lbl.setObjectName("devWindowTitle")
        bl.addWidget(lbl, 1)
        add_btn = QPushButton("＋  Add Device"); add_btn.setObjectName("addDeviceButton")
        add_btn.clicked.connect(self._on_add_device)
        bl.addWidget(add_btn)
        dev_l.addWidget(bar)

        div = QFrame(); div.setFrameShape(QFrame.Shape.HLine)
        div.setObjectName("devWindowDivider"); dev_l.addWidget(div)

        scroll = QScrollArea(); scroll.setWidgetResizable(True)
        scroll.setObjectName("deviceScroll")
        scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
        self._dev_container = QWidget()
        self._dev_inner = QVBoxLayout(self._dev_container)
        self._dev_inner.setContentsMargins(10, 10, 10, 10); self._dev_inner.setSpacing(6)
        self._dev_inner.addStretch()
        scroll.setWidget(self._dev_container)
        dev_l.addWidget(scroll, 1)
        splitter.addWidget(dev_w)

        # Right: signals table
        sig_w = QWidget()
        sig_l = QVBoxLayout(sig_w); sig_l.setContentsMargins(0, 0, 0, 0); sig_l.setSpacing(0)

        sig_bar = QWidget(); sig_bar.setObjectName("cfgGlobalBar")
        sb_lay  = QHBoxLayout(sig_bar); sb_lay.setContentsMargins(10, 7, 10, 7); sb_lay.setSpacing(6)
        sb_lbl  = QLabel("Signals"); sb_lbl.setObjectName("devWindowTitle")
        sb_lay.addWidget(sb_lbl, 1)
        sig_l.addWidget(sig_bar)

        sig_div = QFrame(); sig_div.setFrameShape(QFrame.Shape.HLine)
        sig_div.setObjectName("devWindowDivider"); sig_l.addWidget(sig_div)

        self._signals_tab = _SignalsTab(self.registry)
        self._signals_tab.channel_visibility_changed.connect(self._on_sig_visibility)
        self._signals_tab.channel_name_changed.connect(self._on_sig_name)
        self._signals_tab.channel_unit_changed.connect(self._on_sig_unit)
        self._signals_tab.channel_renamed.connect(self.channel_renamed)
        sig_l.addWidget(self._signals_tab, 1)
        splitter.addWidget(sig_w)

        splitter.setStretchFactor(0, 1)
        splitter.setStretchFactor(1, 1)

        self.tabs.addTab(w, "  Devices  ")

        self._dev_poll = QTimer(self)
        self._dev_poll.setInterval(2000)
        self._dev_poll.timeout.connect(self._refresh_device_status)
        self._dev_poll.start()

        self.refresh_devices()

    def refresh_devices(self):
        for row in self._dev_rows.values():
            self._dev_inner.removeWidget(row); row.deleteLater()
        self._dev_rows.clear()
        for dev in self.registry.all_instances():
            row = DeviceRow(dev)
            row.configure_clicked.connect(self._on_configure_device)
            row.remove_clicked.connect(self._on_remove_device)
            row.name_changed.connect(self._on_device_renamed)
            self._dev_inner.insertWidget(self._dev_inner.count() - 1, row)
            self._dev_rows[dev.info.device_id] = row
        if hasattr(self, "_signals_tab"):
            self._signals_tab.refresh()

    def _refresh_device_status(self):
        for row in self._dev_rows.values():
            row.refresh()

    def _on_add_device(self):
        from ui.add_device_dialog import AddDeviceDialog
        dlg = AddDeviceDialog(self.registry, self)
        if dlg.exec():
            dev = dlg.created_device
            if dev:
                dev.connect()
                self.registry.add_instance(dev)
                self.engine.add_device(dev)
                self.refresh_devices()
                self._signals_tab.refresh()
                self._pipeline_tab.on_device_added()
                self.device_added.emit()

    def _on_device_renamed(self, device_id: str):
        self._signals_tab.refresh()
        self.device_reconfigured.emit(device_id)

    def _on_configure_device(self, device_id: str):
        from ui.config_dialog import DeviceConfigDialog
        dev = self.registry.get_instance(device_id)
        if dev:
            DeviceConfigDialog(dev, self).exec()
            self.refresh_devices()  # rebuilds device rows — picks up new channel count
            self._pipeline_tab.on_device_reconfigured(device_id)
            self.device_reconfigured.emit(device_id)

    def _on_remove_device(self, device_id: str):
        reply = QMessageBox.question(
            self, "Remove Device",
            f"Remove '{device_id}'?  This cannot be undone.",
            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
        )
        if reply == QMessageBox.StandardButton.Yes:
            self.engine.remove_device(device_id)
            self.registry.remove_instance(device_id)
            self.refresh_devices()
            self._signals_tab.refresh()
            self._pipeline_tab.on_device_removed(device_id)
            self.device_removed.emit(device_id)

    # ── Tab 1: Channels ──────────────────────────────────────────────────────
    # Left  — Namespace browser (read-only reference: Signals / Channels / vars)
    # Right — derived / virtual channels (PipelineTab with physical side hidden)

    def _build_channels_tab(self):
        w = QWidget()
        lay = QVBoxLayout(w); lay.setContentsMargins(0, 0, 0, 0); lay.setSpacing(0)

        splitter = QSplitter(Qt.Orientation.Horizontal)
        splitter.setObjectName("channelSplitter")
        lay.addWidget(splitter, 1)

        # Left: namespace browser
        ns_w = QWidget()
        ns_l = QVBoxLayout(ns_w); ns_l.setContentsMargins(0, 0, 0, 0); ns_l.setSpacing(0)

        ns_bar = QWidget(); ns_bar.setObjectName("cfgGlobalBar")
        nb_lay = QHBoxLayout(ns_bar); nb_lay.setContentsMargins(10, 7, 10, 7); nb_lay.setSpacing(6)
        nb_lbl = QLabel("Namespace"); nb_lbl.setObjectName("devWindowTitle")
        nb_lay.addWidget(nb_lbl, 1)
        ns_l.addWidget(ns_bar)

        ns_div = QFrame(); ns_div.setFrameShape(QFrame.Shape.HLine)
        ns_div.setObjectName("devWindowDivider"); ns_l.addWidget(ns_div)

        self._namespace_panel = NamespacePanel(self.registry, self.processor)
        self.processor.processed_data.connect(self._namespace_panel.on_processed_data)
        ns_l.addWidget(self._namespace_panel, 1)

        ns_create_bar = QWidget(); ns_create_bar.setObjectName("cfgGlobalBar")
        nc_lay = QHBoxLayout(ns_create_bar); nc_lay.setContentsMargins(10, 7, 10, 7); nc_lay.setSpacing(6)
        nc_lay.addStretch()
        create_btn = QPushButton("＋ Create Channel"); create_btn.setObjectName("addTraceBtn")
        create_btn.setToolTip("Selected rows become the new Channel's sources — "
                               "none selected creates an empty Channel")
        create_btn.clicked.connect(self._on_create_channel_clicked)
        nc_lay.addWidget(create_btn)
        ns_l.addWidget(ns_create_bar)

        splitter.addWidget(ns_w)

        # Right: derived channels only
        self._pipeline_tab = PipelineTab(self.registry, self.processor)
        self._pipeline_tab.changed.connect(self.pipeline_changed)
        self._pipeline_tab.derived_changed.connect(self.derived_changed)
        self._pipeline_tab.channel_renamed.connect(self.channel_renamed)
        self._pipeline_tab.refresh_derived()  # load derived channels already in processor
                                               # (e.g. window built fresh after profile load)
        inner_splitters = self._pipeline_tab.findChildren(QSplitter)
        if inner_splitters:
            inner_splitters[0].widget(0).setVisible(False)
        splitter.addWidget(self._pipeline_tab)

        # Namespace starts at its content-driven natural width (see
        # NamespacePanel.natural_width() — a query only, not an enforced
        # minimum: a hard setMinimumWidth() here used to fight QMainWindow's
        # dock layout when this same NamespacePanel class is also docked
        # stacked/tabbed with the Control Panel dock, ui/main_window.py).
        # Stretch factor 0 means Channels absorbs window-resize growth;
        # dragging the divider narrower than natural_width() just lets
        # Source etc. scroll — the user's call.
        splitter.setStretchFactor(0, 0)
        splitter.setStretchFactor(1, 1)

        def _init_ns_split():
            ns_w0 = self._namespace_panel.natural_width()
            total = splitter.width()
            splitter.setSizes([ns_w0, max(1, total - ns_w0)])

        QTimer.singleShot(0, _init_ns_split)

        self.tabs.addTab(w, "  Channels  ")

    def _on_create_channel_clicked(self):
        """Create Channel button below the Channels tab's Namespace panel —
        local to this tab (see module docstring). Uses whatever Signal/
        Channel rows are currently selected (ui/namespace_panel.py::
        NamespacePanel.selected_references(), multi-select) as the new
        Channel's sources; none selected creates an empty Channel."""
        refs = self._namespace_panel.selected_references()
        existing       = self.processor.get_derived()
        existing_names = {d.name for d in existing}
        existing_ids   = {d.channel_id for d in existing}

        if len(refs) == 1:
            # Exactly one Signal/Channel selected — the "1 -> 1 passthrough"
            # quick path. No-ops if one already exists for this exact source.
            dev_id, ch_id, ch_name, unit, color = refs[0]
            for dc in existing:
                if dc.kind == "none" and dc.sources == [(dev_id, ch_id)]:
                    return
            name = _dedupe_name(ch_name, existing_names)
            channel_id = _slug_id(name, existing_ids)
            dc = Channel(channel_id=channel_id, name=name, kind="none",
                          sources=[(dev_id, ch_id)], source_names=[ch_name],
                          unit=unit, color=color or "#00d4ff")
        else:
            # Zero selected -> empty Channel, same naming convention
            # PipelineTab._add_virtual() uses for one. Two+ selected -> one
            # Channel sourced from all of them. kind="none" here (not
            # "expression") because it's the only kind that compiles
            # trivially with no expression/script text set yet — Channel.
            # compile() does `compile(f"__result__ = {self.expression}")`
            # for "expression", which is a SyntaxError on the default blank
            # string, so processor.add_derived() below would silently fail
            # and never add the channel. _add_virtual() gets away with
            # defaulting to "expression" because it never calls
            # add_derived() itself — it hands the Channel to the editor and
            # waits for the user's own Apply. This path calls add_derived()
            # immediately, so it needs a kind that survives that. The user
            # picks the real kind/expression afterward in the editor.
            name = _dedupe_name(f"Channel {len(existing) + 1}", existing_names)
            channel_id = _slug_id(name, existing_ids)
            dc = Channel(channel_id=channel_id, name=name, kind="none",
                          sources=[(d, c) for d, c, *_ in refs],
                          source_names=[n for _, _, n, _, _ in refs])

        err = self.processor.add_derived(dc)
        if err is None:
            self._pipeline_tab.refresh_derived()

    def _on_sig_visibility(self, dev_id: str, ch_id: str, enabled: bool):
        self._pipeline_tab.on_channel_enabled_changed(dev_id, ch_id, enabled)
        self.channel_visibility_changed.emit(dev_id, ch_id, enabled)

    def _on_sig_name(self, dev_id: str, ch_id: str, name: str):
        self._pipeline_tab.on_channel_name_changed(dev_id, ch_id, name)
        self.channel_name_changed.emit(dev_id, ch_id, name)

    def _on_sig_unit(self, dev_id: str, ch_id: str, unit: str):
        self._pipeline_tab.on_channel_unit_changed(dev_id, ch_id, unit)
        self.channel_unit_changed.emit(dev_id, ch_id, unit)

    def on_device_added(self):
        self._signals_tab.refresh()
        self._pipeline_tab.on_device_added()

    def on_device_removed(self, dev_id: str):
        self._pipeline_tab.on_device_removed(dev_id)

    def on_device_reconfigured(self, dev_id: str):
        self._signals_tab.refresh()
        self._pipeline_tab.on_device_reconfigured(dev_id)

    def on_channel_enabled_changed(self, dev_id: str, ch_id: str, enabled: bool):
        self._pipeline_tab.on_channel_enabled_changed(dev_id, ch_id, enabled)

    def on_channel_name_changed(self, dev_id: str, ch_id: str, name: str):
        self._pipeline_tab.on_channel_name_changed(dev_id, ch_id, name)

    def on_channel_unit_changed(self, dev_id: str, ch_id: str, unit: str):
        self._pipeline_tab.on_channel_unit_changed(dev_id, ch_id, unit)

    def refresh_derived(self):
        self._pipeline_tab.refresh_derived()

    # ── Tab 2: Plot ──────────────────────────────────────────────────────────

    def _build_plot_tab(self, current_layout: Optional[LayoutConfig]):
        self._plot_tab = _PlotTab(self.registry, self.processor, current_layout, self)
        self._plot_tab.layout_applied.connect(self.layout_applied)
        self.tabs.addTab(self._plot_tab, "  Plot  ")

    def refresh_plot(self, cfg: Optional[LayoutConfig] = None):
        if cfg is not None:
            self._plot_tab.cfg = cfg
        self._plot_tab.refresh_channels()

    # ── Tab switch ───────────────────────────────────────────────────────────

    def _on_tab_changed(self, idx: int):
        if idx == 2:
            self._plot_tab.refresh_channels()

    # ── Show / Close ─────────────────────────────────────────────────────────

    def showEvent(self, e: QShowEvent):
        # closeEvent stops this poll; MainWindow reuses this same ConfigWindow
        # instance across opens (doesn't recreate it), so without restarting
        # here, reopening after a prior close leaves device status frozen at
        # whatever it was at close time — e.g. stuck showing "Connecting…"
        # for an async-connecting device like the motion capture camera.
        self._dev_poll.start()
        super().showEvent(e)

    def closeEvent(self, e: QCloseEvent):
        self._dev_poll.stop()
        self.closed.emit()
        e.accept()