path: root/ui/windows/signals_window.py

"""
ui/windows/signals_window.py

SIGNALS window — toolbar section 3.

Tabs:
  Channels    — per-channel filter stack; user-curated list with add/remove
  Derived     — create virtual channels from physical or derived ones
  Signals     — flat combined list of all physical + derived signals
"""

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

from PyQt6.QtWidgets import (
    QWidget, QVBoxLayout, QHBoxLayout, QLabel, QPushButton,
    QScrollArea, QFrame, QTabWidget, QComboBox, QLineEdit,
    QDoubleSpinBox, QSpinBox, QCheckBox, QTextEdit, QGroupBox,
    QToolButton,
)
from PyQt6.QtCore import Qt, pyqtSignal
from PyQt6.QtGui import QCloseEvent

from devices.device_registry import DeviceRegistry
from core.signal_processor import (
    SignalProcessor, ChannelPipeline, DerivedChannel,
    FilterBase, FILTER_CLASSES,
)

_DERIVED_COLORS = [
    "#f72585","#7209b7","#4361ee","#4cc9f0",
    "#f77f00","#d62828","#588157","#e9c46a",
]


def _channel_combo(registry: DeviceRegistry,
                   processor: Optional[SignalProcessor] = None,
                   include_derived: bool = False,
                   show_unit: bool = False) -> QComboBox:
    cb = QComboBox(); cb.setObjectName("channelPickerCb")
    for dev in registry.all_instances():
        for ch in dev.info.channels:
            if not ch.enabled:
                continue
            label = f"{dev.info.device_id} / {ch.channel_id}  ({ch.name})"
            if show_unit and ch.unit:
                label += f"  [{ch.unit}]"
            cb.addItem(label, userData=(dev.info.device_id, ch.channel_id))
    if include_derived and processor:
        for dc in processor.get_derived():
            label = f"[derived] {dc.channel_id}  ({dc.name})"
            if show_unit and dc.unit:
                label += f"  [{dc.unit}]"
            cb.addItem(label, userData=("derived", dc.channel_id))
    return cb


# ══════════════════════════════════════════════════════════════════════════════
#  Filter row
# ══════════════════════════════════════════════════════════════════════════════

_PARAM_SPECS = {
    "moving_average": [("window", "int",   10,   1,  5000)],
    "median":         [("window", "int",    5,   1,   500)],
    "low_pass":       [("alpha",  "float", 0.1, 0.001, 1.0)],
    "high_pass":      [("alpha",  "float", 0.9, 0.001, 1.0)],
    "scale_offset":   [("scale",  "float", 1.0, -1e6, 1e6),
                       ("offset", "float", 0.0, -1e9, 1e9)],
    "derivative":     [],
    "integral":       [],
}

class FilterRow(QFrame):
    removed = pyqtSignal(object)
    changed = pyqtSignal()

    def __init__(self, filt: FilterBase):
        super().__init__()
        self.filt = filt
        self.setObjectName("traceRow")
        self._build()

    def _build(self):
        lay = QHBoxLayout(self); lay.setContentsMargins(6,4,6,4); lay.setSpacing(8)

        lbl = QLabel(self.filt.name.replace("_"," ").title())
        lbl.setObjectName("traceSource"); lbl.setMinimumWidth(120)
        lay.addWidget(lbl)

        for pname, ptype, default, lo, hi in _PARAM_SPECS.get(self.filt.name, []):
            pl = QLabel(f"{pname}:"); pl.setObjectName("pwmLabel")
            lay.addWidget(pl)
            if ptype == "int":
                w = QSpinBox(); w.setRange(int(lo), int(hi))
                w.setValue(int(self.filt.params.get(pname, default)))
                w.setFixedWidth(70); w.setObjectName("traceWidthSpin")
                w.valueChanged.connect(lambda v, p=pname: self._upd(p, v))
            else:
                w = QDoubleSpinBox(); w.setRange(lo, hi); w.setDecimals(4)
                w.setValue(float(self.filt.params.get(pname, default)))
                w.setFixedWidth(88); w.setObjectName("traceWidthSpin")
                w.valueChanged.connect(lambda v, p=pname: self._upd(p, v))
            lay.addWidget(w)

        lay.addStretch()
        rm = QToolButton(); rm.setText("✕"); rm.setObjectName("traceRemoveBtn")
        rm.setFixedSize(22, 22); rm.clicked.connect(lambda: self.removed.emit(self))
        lay.addWidget(rm)

    def _upd(self, name, value):
        self.filt.params[name] = value
        cls = FILTER_CLASSES.get(self.filt.name)
        if cls:
            nf = cls(**self.filt.params); self.filt.__dict__.update(nf.__dict__)
        self.changed.emit()


# monkey-patch QLabel.also for inline objectName
from PyQt6.QtWidgets import QLabel as _QLabel
def _also(self, fn): fn(self); return self
_QLabel.also = _also


# ══════════════════════════════════════════════════════════════════════════════
#  Channel Pipeline Block — collapsible filter stack for one channel
# ══════════════════════════════════════════════════════════════════════════════

class ChannelPipelineBlock(QFrame):
    changed = pyqtSignal()
    removed = pyqtSignal(object)   # emits self

    def __init__(self, dev_id: str, ch_id: str, ch_name: str, unit: str,
                 processor: SignalProcessor):
        super().__init__()
        self.dev_id    = dev_id
        self.ch_id     = ch_id
        self.processor = processor
        self._rows: List[FilterRow] = []
        self._cur_pipeline: Optional[ChannelPipeline] = None
        self._expanded = False
        self.setObjectName("plotBlock")
        self._build(ch_name, unit)
        self._load()

    def _build(self, ch_name: str, unit: str):
        outer = QVBoxLayout(self); outer.setContentsMargins(0,0,0,0); outer.setSpacing(0)

        # Header
        hdr = QWidget(); hdr.setObjectName("plotBlockHeader"); hdr.setFixedHeight(32)
        hl  = QHBoxLayout(hdr); hl.setContentsMargins(8,0,6,0)
        title = f"{self.dev_id} / {self.ch_id}  ({ch_name})"
        if unit:
            title += f"  [{unit}]"
        lbl = QLabel(title); lbl.setObjectName("traceSource")
        hl.addWidget(lbl, 1)

        rm_btn = QToolButton(); rm_btn.setText("✕")
        rm_btn.setObjectName("traceRemoveBtn"); rm_btn.setFixedSize(22, 22)
        rm_btn.clicked.connect(lambda: self.removed.emit(self))
        hl.addWidget(rm_btn)

        self._toggle_btn = QToolButton(); self._toggle_btn.setText("▶")
        self._toggle_btn.setObjectName("traceRemoveBtn"); self._toggle_btn.setFixedSize(22, 22)
        self._toggle_btn.clicked.connect(self._toggle)
        hl.addWidget(self._toggle_btn)
        outer.addWidget(hdr)
        hdr.mousePressEvent = lambda e: self._toggle()

        # Body
        self._body = QWidget(); self._body.setObjectName("plotBlockSettings")
        bl = QVBoxLayout(self._body)
        bl.setContentsMargins(10,8,10,10); bl.setSpacing(6)

        self._en_chk = QCheckBox("Pipeline enabled"); self._en_chk.setChecked(True)
        self._en_chk.toggled.connect(self._on_enable)
        bl.addWidget(self._en_chk)

        self._filter_area = QWidget()
        self._filter_lay  = QVBoxLayout(self._filter_area)
        self._filter_lay.setContentsMargins(0,0,0,0); self._filter_lay.setSpacing(3)
        bl.addWidget(self._filter_area)

        add_bar = QHBoxLayout()
        self._filt_cb = QComboBox(); self._filt_cb.setObjectName("channelPickerCb")
        self._filt_cb.addItems([k.replace("_"," ").title() for k in FILTER_CLASSES])
        add_bar.addWidget(self._filt_cb, 1)
        add_btn = QPushButton("＋ Add Filter"); add_btn.setObjectName("addTraceBtn")
        add_btn.clicked.connect(self._add_filter)
        add_bar.addWidget(add_btn)
        bl.addLayout(add_bar)

        ap_row = QHBoxLayout(); ap_row.addStretch()
        ap_btn = QPushButton("✓  Apply"); ap_btn.setObjectName("applyButton")
        ap_btn.clicked.connect(self._push)
        ap_row.addWidget(ap_btn)
        bl.addLayout(ap_row)

        outer.addWidget(self._body)
        self._body.setVisible(False)

    def _toggle(self):
        self._expanded = not self._expanded
        self._body.setVisible(self._expanded)
        self._toggle_btn.setText("▼" if self._expanded else "▶")

    def _load(self):
        pipeline = self.processor.get_pipeline(self.dev_id, self.ch_id)
        if pipeline is None:
            pipeline = ChannelPipeline(device_id=self.dev_id, channel_id=self.ch_id)
            self.processor.set_pipeline(pipeline)
        self._cur_pipeline = pipeline
        self._en_chk.setChecked(pipeline.enabled)
        for f in pipeline.filters:
            self._add_filter_row(f)

    def _add_filter(self):
        key  = list(FILTER_CLASSES.keys())[self._filt_cb.currentIndex()]
        filt = FILTER_CLASSES[key]()
        if self._cur_pipeline:
            self._cur_pipeline.filters.append(filt)
        self._add_filter_row(filt)
        self._push()

    def _add_filter_row(self, filt: FilterBase):
        row = FilterRow(filt)
        row.removed.connect(self._remove_filter)
        row.changed.connect(self._push)
        self._rows.append(row)
        self._filter_lay.addWidget(row)

    def _remove_filter(self, row: FilterRow):
        if self._cur_pipeline and row.filt in self._cur_pipeline.filters:
            self._cur_pipeline.filters.remove(row.filt)
        self._rows.remove(row)
        self._filter_lay.removeWidget(row); row.deleteLater()
        self._push()

    def _on_enable(self, v: bool):
        if self._cur_pipeline:
            self._cur_pipeline.enabled = v
            self._push()

    def _push(self):
        if self._cur_pipeline:
            self.processor.set_pipeline(self._cur_pipeline)
        self.changed.emit()


# ══════════════════════════════════════════════════════════════════════════════
#  Channels Tab (formerly Pipeline Tab) — user-curated channel list
# ══════════════════════════════════════════════════════════════════════════════

class PipelineTab(QWidget):
    changed = pyqtSignal()

    def __init__(self, registry: DeviceRegistry, processor: SignalProcessor):
        super().__init__()
        self.registry        = registry
        self.processor       = processor
        self._shown:  Set[Tuple[str,str]]                        = set()
        self._blocks: dict[Tuple[str,str], ChannelPipelineBlock] = {}
        self._build()

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

        # Add-channel bar at top
        add_bar = QWidget(); add_bar.setObjectName("cfgGlobalBar")
        ab_lay  = QHBoxLayout(add_bar); ab_lay.setContentsMargins(10,7,10,7); ab_lay.setSpacing(6)
        ab_lay.addWidget(QLabel("Add:"))
        self._avail_cb = QComboBox(); self._avail_cb.setObjectName("channelPickerCb")
        ab_lay.addWidget(self._avail_cb, 1)
        add_btn = QPushButton("＋ Add Channel"); add_btn.setObjectName("addTraceBtn")
        add_btn.clicked.connect(self._on_add_channel)
        ab_lay.addWidget(add_btn)
        lay.addWidget(add_bar)

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

        scroll = QScrollArea(); scroll.setWidgetResizable(True)
        scroll.setObjectName("deviceScroll")
        scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
        self._cont  = QWidget()
        self._inner = QVBoxLayout(self._cont)
        self._inner.setContentsMargins(10,10,10,10); self._inner.setSpacing(6)
        self._inner.addStretch()
        scroll.setWidget(self._cont)
        lay.addWidget(scroll, 1)

        # Populate with enabled device channels on startup
        for dev in self.registry.all_instances():
            for ch in dev.info.channels:
                if ch.enabled:
                    self._add_block(dev.info.device_id, ch.channel_id, ch.name, ch.unit)

        self._refresh_avail_cb()

    # ── Channel block management ──────────────────────────────────────────────

    def _add_block(self, dev_id: str, ch_id: str, ch_name: str, unit: str):
        if (dev_id, ch_id) in self._shown:
            return
        self._shown.add((dev_id, ch_id))
        block = ChannelPipelineBlock(dev_id, ch_id, ch_name, unit, self.processor)
        block.changed.connect(self.changed)
        block.removed.connect(self._on_remove_block)
        self._blocks[(dev_id, ch_id)] = block
        # Insert before the trailing stretch
        self._inner.insertWidget(self._inner.count() - 1, block)

    def on_channel_enabled_changed(self, dev_id: str, ch_id: str, enabled: bool):
        key = (dev_id, ch_id)
        if enabled:
            if key not in self._shown:
                dev = self.registry.get_instance(dev_id)
                if dev:
                    ch = dev.get_channel(ch_id)
                    if ch:
                        self._add_block(dev_id, ch_id, ch.name, ch.unit)
            else:
                block = self._blocks.get(key)
                if block:
                    block.setVisible(True)
        else:
            block = self._blocks.get(key)
            if block:
                block.setVisible(False)
        self._refresh_avail_cb()

    def _on_add_channel(self):
        data = self._avail_cb.currentData()
        if not data:
            return
        dev_id, ch_id = data
        dev = self.registry.get_instance(dev_id)
        if not dev:
            return
        ch = dev.get_channel(ch_id)
        if not ch:
            return
        self._add_block(dev_id, ch_id, ch.name, ch.unit)
        self._refresh_avail_cb()

    def _on_remove_block(self, block: ChannelPipelineBlock):
        key = (block.dev_id, block.ch_id)
        self._shown.discard(key)
        self._blocks.pop(key, None)
        self._inner.removeWidget(block)
        block.deleteLater()
        self._refresh_avail_cb()

    def _refresh_avail_cb(self):
        self._avail_cb.clear()
        for dev in self.registry.all_instances():
            for ch in dev.info.channels:
                if not ch.enabled:
                    continue
                if (dev.info.device_id, ch.channel_id) not in self._shown:
                    label = f"{dev.info.device_id} / {ch.channel_id}  ({ch.name})"
                    if ch.unit:
                        label += f"  [{ch.unit}]"
                    self._avail_cb.addItem(label,
                                           userData=(dev.info.device_id, ch.channel_id))


# ══════════════════════════════════════════════════════════════════════════════
#  Derived editor for one DerivedChannel
# ══════════════════════════════════════════════════════════════════════════════

_BUILTIN   = ["derivative", "second_derivative", "power", "rms", "difference", "sum"]
_SCRIPT    = ["expression", "function", "custom_script"]
_ALL_KINDS = _BUILTIN + _SCRIPT

_KIND_DISPLAY = {k: k.replace("_", " ").title() for k in _ALL_KINDS}

_KIND_HELP = {
    "derivative":        "Backward difference dy/dt from 1 source",
    "second_derivative": "Second derivative d²y/dt² from 1 source",
    "power":        "V × I  from 2 sources (voltage, current)",
    "rms":          "Rolling RMS from 1 source  (set window below)",
    "difference":   "source[0] − source[1]  from 2 sources",
    "sum":          "Σ all source values",
    "expression":   "x = list of source values,  t = elapsed time (s)\nExample:  x[0] * 3.14159 / 180",
    "function":     "def compute(x, t):\n    # x = source values list\n    return x[0] * 2.0",
    "custom_script":"Full Python.  Must define:  def compute(x, t): ...",
}


class DerivedBlock(QFrame):
    removed = pyqtSignal(object)
    applied = pyqtSignal(object)  # DerivedChannel

    def __init__(self, dc: DerivedChannel, registry: DeviceRegistry,
                 processor: SignalProcessor):
        super().__init__()
        self.dc = dc; self.registry = registry; self.processor = processor
        self.setObjectName("plotBlock")
        self._src_combos: List[QComboBox] = []
        self._build()

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

        # Header
        hdr = QWidget(); hdr.setObjectName("plotBlockHeader"); hdr.setFixedHeight(32)
        hl  = QHBoxLayout(hdr); hl.setContentsMargins(8,0,6,0)
        self._name = QLineEdit(self.dc.name); self._name.setObjectName("plotBlockTitle")
        self._name.textChanged.connect(lambda t: setattr(self.dc,"name",t))
        hl.addWidget(self._name, 1)
        self._en = QCheckBox(); self._en.setChecked(self.dc.enabled)
        self._en.setToolTip("Enable")
        self._en.toggled.connect(lambda v: setattr(self.dc,"enabled",v))
        hl.addWidget(self._en)
        rm = QToolButton(); rm.setText("✕"); rm.setObjectName("plotRemoveBtn")
        rm.setFixedSize(22,22); rm.clicked.connect(lambda: self.removed.emit(self))
        hl.addWidget(rm)
        outer.addWidget(hdr)

        # Body
        body = QWidget(); body.setObjectName("plotBlockSettings")
        bl = QVBoxLayout(body); bl.setContentsMargins(10,8,10,10); bl.setSpacing(6)

        # ID / unit row
        meta = QHBoxLayout()
        meta.addWidget(QLabel("ID:"))
        self._id = QLineEdit(self.dc.channel_id)
        self._id.setObjectName("traceLabel"); self._id.setFixedWidth(100)
        self._id.textChanged.connect(lambda t: setattr(self.dc,"channel_id",t))
        meta.addWidget(self._id)
        meta.addWidget(QLabel("Unit:"))
        self._unit = QLineEdit(self.dc.unit)
        self._unit.setObjectName("traceLabel"); self._unit.setFixedWidth(60)
        self._unit.textChanged.connect(lambda t: setattr(self.dc,"unit",t))
        meta.addWidget(self._unit); meta.addStretch()
        bl.addLayout(meta)

        # Kind combo + help
        k_row = QHBoxLayout(); k_row.addWidget(QLabel("Kind:"))
        self._kind_cb = QComboBox(); self._kind_cb.setObjectName("channelPickerCb")
        self._kind_cb.addItems([_KIND_DISPLAY[k] for k in _ALL_KINDS])
        cur_idx = _ALL_KINDS.index(self.dc.kind) if self.dc.kind in _ALL_KINDS else 0
        self._kind_cb.setCurrentIndex(cur_idx)
        self._kind_cb.currentIndexChanged.connect(self._on_kind)
        k_row.addWidget(self._kind_cb); k_row.addStretch()
        bl.addLayout(k_row)
        self._help = QLabel(_KIND_HELP.get(self.dc.kind,""))
        self._help.setObjectName("traceSource"); self._help.setWordWrap(True)
        bl.addWidget(self._help)

        # RMS window
        self._win_row = QHBoxLayout()
        self._win_row.addWidget(QLabel("Window samples:"))
        self._win_sp = QSpinBox(); self._win_sp.setRange(2,10000)
        self._win_sp.setValue(self.dc.params.get("window",20))
        self._win_sp.setObjectName("traceWidthSpin"); self._win_sp.setFixedWidth(80)
        self._win_sp.valueChanged.connect(lambda v: self.dc.params.update({"window":v}))
        self._win_row.addWidget(self._win_sp); self._win_row.addStretch()
        self._win_widget = QWidget(); self._win_widget.setLayout(self._win_row)
        bl.addWidget(self._win_widget)

        # Sources — include derived channels as valid sources
        src_grp = QGroupBox("Sources"); src_grp.setObjectName("cfgGlobalBar")
        src_lay = QVBoxLayout(src_grp); src_lay.setContentsMargins(6,4,6,4); src_lay.setSpacing(3)
        self._src_cont = QWidget(); self._src_vlay = QVBoxLayout(self._src_cont)
        self._src_vlay.setContentsMargins(0,0,0,0); self._src_vlay.setSpacing(3)
        for s in self.dc.sources:
            self._add_src(s)
        add_s = QPushButton("＋ Add Source"); add_s.setObjectName("addTraceBtn")
        add_s.clicked.connect(lambda: self._add_src())
        src_lay.addWidget(self._src_cont); src_lay.addWidget(add_s)
        bl.addWidget(src_grp)

        # Code editor
        self._code_grp = QGroupBox("Code")
        code_lay = QVBoxLayout(self._code_grp); code_lay.setContentsMargins(6,4,6,4)
        self._code = QTextEdit(); self._code.setObjectName("codeEditor")
        self._code.setMinimumHeight(90); self._code.setMaximumHeight(180)
        txt = self.dc.expression if self.dc.kind=="expression" else self.dc.script
        self._code.setPlainText(txt)
        code_lay.addWidget(self._code)
        bl.addWidget(self._code_grp)

        # Status + apply
        ap_row = QHBoxLayout()
        self._st = QLabel(""); self._st.setObjectName("traceSource")
        ap_row.addWidget(self._st, 1)
        ap = QPushButton("✓  Apply"); ap.setObjectName("applyButton")
        ap.clicked.connect(self._apply)
        ap_row.addWidget(ap)
        bl.addLayout(ap_row)

        outer.addWidget(body)
        self._update_visibility()

    def _add_src(self, src=None):
        row = QHBoxLayout()
        # Include derived channels as valid sources (enables chaining)
        cb = _channel_combo(self.registry, self.processor,
                            include_derived=True, show_unit=True)
        cb.setObjectName("channelPickerCb")
        if src:
            for i in range(cb.count()):
                if cb.itemData(i) == src:
                    cb.setCurrentIndex(i); break
        rm = QToolButton(); rm.setText("✕"); rm.setObjectName("traceRemoveBtn")
        rm.setFixedSize(22,22); rm.clicked.connect(lambda: self._rm_src(row, cb))
        row.addWidget(cb,1); row.addWidget(rm)
        self._src_vlay.addLayout(row)
        self._src_combos.append(cb)

    def _rm_src(self, row, cb):
        if cb in self._src_combos:
            self._src_combos.remove(cb)
        while row.count():
            it = row.takeAt(0)
            if it.widget(): it.widget().deleteLater()

    def _on_kind(self, idx: int):
        k = _ALL_KINDS[idx]
        self.dc.kind = k
        self._help.setText(_KIND_HELP.get(k,""))
        self._update_visibility()

    def _update_visibility(self):
        self._code_grp.setVisible(self.dc.kind in _SCRIPT)
        self._win_widget.setVisible(self.dc.kind == "rms")

    def _apply(self):
        self.dc.sources = [cb.currentData() for cb in self._src_combos
                           if cb.currentData()]
        if self.dc.kind == "expression":
            self.dc.expression = self._code.toPlainText().strip()
        elif self.dc.kind in ("function","custom_script"):
            self.dc.script = self._code.toPlainText()
        err = self.processor.add_derived(self.dc)
        if err:
            self._st.setText(f"⚠ {err[:100]}")
            self._st.setStyleSheet("color:#ef4444;")
        else:
            self._st.setText("✓ Applied")
            self._st.setStyleSheet("color:#22c55e;")
            self.applied.emit(self.dc)


# ══════════════════════════════════════════════════════════════════════════════
#  Signals Tab — flat unified list of all signals
# ══════════════════════════════════════════════════════════════════════════════

class SignalsTab(QWidget):
    changed         = pyqtSignal()
    channel_toggled = pyqtSignal(str, str, bool)  # dev_id, ch_id, enabled

    def __init__(self, registry: DeviceRegistry, processor: SignalProcessor):
        super().__init__()
        self.registry  = registry
        self.processor = processor
        self._build()

    def _build(self):
        scroll = QScrollArea(); scroll.setWidgetResizable(True)
        scroll.setObjectName("deviceScroll")
        self._cont = QWidget()
        self._lay  = QVBoxLayout(self._cont)
        self._lay.setContentsMargins(8,8,8,8); self._lay.setSpacing(2)
        scroll.setWidget(self._cont)
        root = QVBoxLayout(self); root.setContentsMargins(0,0,0,0)
        root.addWidget(scroll)
        self.refresh()

    def refresh(self):
        while self._lay.count():
            it = self._lay.takeAt(0)
            if it.widget(): it.widget().deleteLater()

        # Physical channels — flat list across all devices
        for dev in self.registry.all_instances():
            for ch in dev.info.channels:
                dev_id_cap = dev.info.device_id
                ch_id_cap  = ch.channel_id
                self._lay.addWidget(self._make_row(
                    color   = ch.color,
                    name    = f"{ch.channel_id}  —  {ch.name}",
                    unit    = ch.unit,
                    source  = dev_id_cap,
                    enabled = ch.enabled,
                    on_toggle = lambda v, c=ch, d=dev_id_cap, ci=ch_id_cap: (
                        setattr(c, "enabled", v),
                        self.changed.emit(),
                        self.channel_toggled.emit(d, ci, v),
                    ),
                ))

        # Thin divider before derived (only if both sections have entries)
        if self.registry.all_instances() and self.processor.get_derived():
            div = QFrame(); div.setFrameShape(QFrame.Shape.HLine)
            div.setObjectName("devWindowDivider")
            self._lay.addWidget(div)

        # Derived signals
        for dc in self.processor.get_derived():
            self._lay.addWidget(self._make_row(
                color   = dc.color,
                name    = f"{dc.channel_id}  —  {dc.name}",
                unit    = dc.unit,
                source  = "derived",
                enabled = dc.enabled,
                on_toggle = lambda v, d=dc: (setattr(d,"enabled",v), self.changed.emit()),
            ))

        self._lay.addStretch()

    def _make_row(self, color: str, name: str, unit: str, source: str,
                  enabled: bool, on_toggle) -> QFrame:
        row = QFrame(); row.setObjectName("traceRow")
        lay = QHBoxLayout(row); lay.setContentsMargins(8,4,8,4); lay.setSpacing(8)

        dot = QLabel("●"); dot.setStyleSheet(f"color:{color};"); dot.setFixedWidth(14)
        lay.addWidget(dot)

        chk = QCheckBox(name); chk.setChecked(enabled)
        chk.toggled.connect(on_toggle)
        lay.addWidget(chk, 1)

        if unit:
            ul = QLabel(unit); ul.setObjectName("traceSource")
            ul.setFixedWidth(52)
            ul.setAlignment(Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter)
            lay.addWidget(ul)

        sl = QLabel(source); sl.setObjectName("traceSource")
        sl.setFixedWidth(72)
        sl.setAlignment(Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter)
        lay.addWidget(sl)

        return row


# ══════════════════════════════════════════════════════════════════════════════
#  SignalsWindow — main
# ══════════════════════════════════════════════════════════════════════════════

class SignalsWindow(QWidget):
    pipeline_changed   = pyqtSignal()
    derived_changed    = pyqtSignal()
    visibility_changed = pyqtSignal()
    channel_toggled    = pyqtSignal(str, str, bool)  # dev_id, ch_id, enabled
    closed             = pyqtSignal()

    def __init__(self, registry: DeviceRegistry,
                 processor: SignalProcessor, parent=None):
        super().__init__(parent, Qt.WindowType.Window | Qt.WindowType.Tool)
        self.registry  = registry
        self.processor = processor
        self._derived_blocks: List[DerivedBlock] = []
        self._color_idx = 0

        self.setWindowTitle("Signals")
        self.setMinimumSize(640, 520)
        self.resize(740, 640)
        self._build()

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

        # Header
        hdr = QWidget(); hdr.setObjectName("devWindowTitleBar"); hdr.setFixedHeight(44)
        hl  = QHBoxLayout(hdr); hl.setContentsMargins(14,0,14,0)
        hl.addWidget(QLabel("SIGNALS").also(lambda w: w.setObjectName("devWindowTitle")), 1)
        root.addWidget(hdr)
        div = QFrame(); div.setFrameShape(QFrame.Shape.HLine)
        div.setObjectName("devWindowDivider"); root.addWidget(div)

        tabs = QTabWidget(); tabs.setObjectName("signalBuilderTabs")
        root.addWidget(tabs, 1)

        # Tab 1: Channels (filter pipelines per channel)
        self._pip_tab = PipelineTab(self.registry, self.processor)
        self._pip_tab.changed.connect(self.pipeline_changed)
        tabs.addTab(self._pip_tab, "  Channels  ")

        # Tab 2: Derived channels
        tabs.addTab(self._build_derived_tab(), "  Derived  ")

        # Tab 3: Flat signals list
        self._vis_tab = SignalsTab(self.registry, self.processor)
        self._vis_tab.changed.connect(self.visibility_changed)
        self._vis_tab.channel_toggled.connect(self._on_vis_tab_toggled)
        tabs.addTab(self._vis_tab, "  Signals  ")

        # Keep Signals tab in sync when derived channels are added/removed
        self.derived_changed.connect(self._vis_tab.refresh)

        # Populate from processor state (handles opening window after profile load)
        self.refresh_derived()

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

        top = QWidget(); top.setObjectName("cfgGlobalBar")
        tl  = QHBoxLayout(top); tl.setContentsMargins(10,7,10,7)
        tl.addWidget(QLabel("New:"))
        self._new_kind = QComboBox(); self._new_kind.setObjectName("channelPickerCb")
        self._new_kind.addItems([_KIND_DISPLAY[k] for k in _ALL_KINDS])
        tl.addWidget(self._new_kind)
        cr = QPushButton("＋  Create Derived Channel")
        cr.setObjectName("addDeviceButton"); cr.clicked.connect(self._add_derived)
        tl.addWidget(cr); tl.addStretch()
        lay.addWidget(top)

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

        scroll = QScrollArea(); scroll.setWidgetResizable(True)
        scroll.setObjectName("deviceScroll")
        self._d_cont = QWidget()
        self._d_lay  = QVBoxLayout(self._d_cont)
        self._d_lay.setContentsMargins(10,10,10,10); self._d_lay.setSpacing(10)
        self._d_lay.addStretch()
        scroll.setWidget(self._d_cont)
        lay.addWidget(scroll, 1)
        return w

    def _add_derived(self):
        kind  = _ALL_KINDS[self._new_kind.currentIndex()]
        color = _DERIVED_COLORS[self._color_idx % len(_DERIVED_COLORS)]
        self._color_idx += 1
        n  = len(self._derived_blocks) + 1
        dc = DerivedChannel(channel_id=f"sig_{n}", name=f"Signal {n}",
                            kind=kind, color=color)
        blk = DerivedBlock(dc, self.registry, self.processor)
        blk.removed.connect(self._rm_derived)
        blk.applied.connect(lambda _: self.derived_changed.emit())
        self._derived_blocks.append(blk)
        self._d_lay.insertWidget(self._d_lay.count()-1, blk)

    def _rm_derived(self, blk: DerivedBlock):
        self.processor.remove_derived(blk.dc.channel_id)
        self._derived_blocks.remove(blk)
        self._d_lay.removeWidget(blk); blk.deleteLater()
        self.derived_changed.emit()

    def refresh_derived(self):
        """Rebuild DerivedBlock widgets from processor state (called after profile load)."""
        for blk in self._derived_blocks:
            self._d_lay.removeWidget(blk); blk.deleteLater()
        self._derived_blocks.clear()

        for dc in self.processor.get_derived():
            blk = DerivedBlock(dc, self.registry, self.processor)
            blk.removed.connect(self._rm_derived)
            blk.applied.connect(lambda _: self.derived_changed.emit())
            self._derived_blocks.append(blk)
            self._d_lay.insertWidget(self._d_lay.count() - 1, blk)

        self._color_idx = len(self._derived_blocks)
        self._vis_tab.refresh()

    def _on_vis_tab_toggled(self, dev_id: str, ch_id: str, enabled: bool):
        """Signals tab toggled a channel — propagate to pipeline + chart without re-refreshing vis_tab."""
        self._pip_tab.on_channel_enabled_changed(dev_id, ch_id, enabled)
        self.channel_toggled.emit(dev_id, ch_id, enabled)

    def on_channel_enabled_changed(self, dev_id: str, ch_id: str, enabled: bool):
        """Called from outside (Devices window) — update pipeline block and sync vis_tab checkboxes."""
        self._pip_tab.on_channel_enabled_changed(dev_id, ch_id, enabled)
        self._vis_tab.refresh()

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