#!/usr/bin/env python3
"""
DBN MQTT Tool — DLD960 IoT MQTT 设备管理工具
跨平台桌面软件 (PySide6)
"""

import sys
import os
import json
from datetime import datetime
from typing import Optional

sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

from PySide6.QtWidgets import (
    QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout,
    QLabel, QLineEdit, QPushButton, QTreeWidget, QTreeWidgetItem,
    QTabWidget, QTextEdit, QGroupBox, QGridLayout, QCheckBox,
    QSplitter, QMessageBox, QHeaderView, QFrame,
    QComboBox, QSpinBox, QPlainTextEdit,
)
from PySide6.QtCore import Qt, QTimer, Signal, Slot
from PySide6.QtGui import QFont, QColor, QTextCursor
import paho.mqtt.client as mqtt

from dbn_mqtt_tool.mqtt_client import MqttClient, BrokerConfig
from dbn_mqtt_tool.device_manager import DeviceManager
from dbn_mqtt_tool.protocol import (
    CMD_DEV_INFO_QUERY, CMD_SSC_NET_QUERY, CMD_IOT_NET_QUERY,
    CMD_IOT_TOPIC_QUERY, CMD_LOOP_PARAM_QUERY, CMD_REPORT_CONFIG,
    CMD_SSC_NET_SET, CMD_IOT_NET_SET, CMD_IOT_TOPIC_SET,
    CMD_PWD_VERIFY, CMD_PWD_SET, CMD_FACTORY_RESET, CMD_DEVICE_RESET,
    CMD_LOOP_DATA, CMD_EVENT_REPORT, CMD_HEARTBEAT, CMD_INITIALIZE,
    ERROR_MSGS, FREQ_LEVELS, OUTPUT_MODES, EVENT_TYPES,
    data_ssc_net_set, data_iot_net_set, data_iot_topic_set,
    data_pwd_verify, data_pwd_set, data_report_config,
    build_request, next_msg_id,
    topic_down, topic_up,
)

class MainWindow(QMainWindow):
    _mqtt_status = Signal(bool, str)
    _mqtt_msg = Signal(str, str, object)
    _devices_changed = Signal()

    def __init__(self):
        super().__init__()
        self.setWindowTitle("DBN MQTT Tool — DLD960 IoT 设备管理")
        self.resize(1280, 800)
        self.setMinimumSize(960, 640)

        self._mqtt = MqttClient()
        self._devmgr = DeviceManager()

        self._mqtt.on_status_change(lambda c, m: self._mqtt_status.emit(c, m))
        self._mqtt.on_message(lambda t, s, p: self._mqtt_msg.emit(t, s, p))
        self._devmgr.on_change(lambda: self._devices_changed.emit())

        self._mqtt_status.connect(self._on_status)
        self._mqtt_msg.connect(self._on_message)
        self._devices_changed.connect(self._refresh_devices)

        self._build_ui()
        self._log("DBN MQTT Tool 已启动")

    # ================================================================
    # UI 构建
    # ================================================================

    def _build_ui(self):
        central = QWidget()
        self.setCentralWidget(central)
        root = QVBoxLayout(central)
        root.setContentsMargins(8, 8, 8, 8)
        root.setSpacing(6)

        # -- 顶栏 --
        root.addWidget(self._build_top_bar())

        # -- 主体 --
        splitter = QSplitter(Qt.Horizontal)

        left = self._build_device_panel()
        splitter.addWidget(left)

        self._notebook = QTabWidget()
        self._notebook.addTab(self._build_info_tab(), "设备信息")
        self._notebook.addTab(self._build_config_tab(), "参数配置")
        self._notebook.addTab(self._build_data_tab(), "实时数据")
        self._notebook.addTab(self._build_log_tab(), "日志")
        self._notebook.addTab(self._build_simulate_tab(), "模拟上报")
        self._notebook.addTab(self._build_proto_topic_tab(), "协议Topic")
        self._notebook.addTab(self._build_custom_topic_tab(), "自定义Topic")
        splitter.addWidget(self._notebook)

        splitter.setSizes([280, 960])
        root.addWidget(splitter, 1)

    def _build_top_bar(self) -> QWidget:
        bar = QWidget()
        layout = QHBoxLayout(bar)
        layout.setContentsMargins(0, 0, 0, 0)
        layout.setSpacing(6)

        layout.addWidget(QLabel("Broker:"))
        self._host_edit = QLineEdit("121.37.20.199")
        self._host_edit.setMaximumWidth(140)
        layout.addWidget(self._host_edit)

        layout.addWidget(QLabel("Port:"))
        self._port_edit = QLineEdit("1883")
        self._port_edit.setMaximumWidth(60)
        layout.addWidget(self._port_edit)

        layout.addWidget(QLabel("用户:"))
        self._user_edit = QLineEdit()
        self._user_edit.setMaximumWidth(90)
        layout.addWidget(self._user_edit)

        layout.addWidget(QLabel("密码:"))
        self._pass_edit = QLineEdit()
        self._pass_edit.setMaximumWidth(90)
        self._pass_edit.setEchoMode(QLineEdit.Password)
        layout.addWidget(self._pass_edit)

        self._btn_conn = QPushButton("连接")
        self._btn_conn.setFixedWidth(70)
        self._btn_conn.clicked.connect(self._toggle_connect)
        layout.addWidget(self._btn_conn)

        self._status_label = QLabel("● 未连接")
        self._status_label.setStyleSheet("color: red; font-weight: bold;")
        layout.addWidget(self._status_label)

        layout.addStretch()
        return bar

    def _build_device_panel(self) -> QWidget:
        w = QWidget()
        layout = QVBoxLayout(w)
        layout.setContentsMargins(0, 0, 0, 0)

        layout.addWidget(QLabel("<b>设备列表</b>"))

        self._dev_tree = QTreeWidget()
        self._dev_tree.setHeaderLabels(["设备序列码", "型号"])
        self._dev_tree.setRootIsDecorated(False)
        self._dev_tree.header().setStretchLastSection(True)
        self._dev_tree.itemSelectionChanged.connect(self._on_dev_select)
        layout.addWidget(self._dev_tree, 1)

        btn_row = QHBoxLayout()
        btn_query = QPushButton("查询设备信息")
        btn_query.clicked.connect(self._query_dev_info)
        btn_row.addWidget(btn_query)

        btn_all = QPushButton("查询全部")
        btn_all.clicked.connect(self._query_all)
        btn_row.addWidget(btn_all)

        layout.addLayout(btn_row)
        return w

    def _build_info_tab(self) -> QWidget:
        w = QWidget()
        layout = QVBoxLayout(w)
        self._info_text = QTextEdit()
        self._info_text.setReadOnly(True)
        self._info_text.setFont(QFont("Consolas", 10))
        layout.addWidget(self._info_text)
        return w

    def _build_config_tab(self) -> QWidget:
        w = QWidget()
        layout = QVBoxLayout(w)

        # -- SSC 网络 --
        g1 = QGroupBox("SSC 网络配置")
        g1_layout = QGridLayout(g1)
        fields_ssc = [
            ("设备 IP", "ssc_ip"), ("子网掩码", "ssc_mask"),
            ("网关", "ssc_gw"), ("LSSC IP", "ssc_lssc"),
            ("DNS", "ssc_dns"), ("端口", "ssc_port"),
        ]
        for i, (label, name) in enumerate(fields_ssc):
            g1_layout.addWidget(QLabel(label + ":"), i // 2, (i % 2) * 2)
            edit = QLineEdit()
            edit.setMaximumWidth(140)
            g1_layout.addWidget(edit, i // 2, (i % 2) * 2 + 1)
            setattr(self, f"_edit_{name}", edit)

        btn_row = QHBoxLayout()
        b1 = QPushButton("查询")
        b1.clicked.connect(self._query_ssc_net)
        b2 = QPushButton("设置")
        b2.clicked.connect(self._set_ssc_net)
        btn_row.addWidget(b1)
        btn_row.addWidget(b2)
        btn_row.addStretch()
        g1_layout.addLayout(btn_row, 3, 0, 1, 4)
        layout.addWidget(g1)

        # -- IoT 网络 --
        g2 = QGroupBox("IoT 网络配置")
        g2_layout = QGridLayout(g2)
        fields_iot = [
            ("MQTT Host", "iot_host"), ("MQTT Port", "iot_port"),
            ("Client ID", "iot_cid"), ("用户名", "iot_user"),
            ("密码", "iot_pass"),
        ]
        for i, (label, name) in enumerate(fields_iot):
            g2_layout.addWidget(QLabel(label + ":"), i, 0)
            edit = QLineEdit()
            edit.setMinimumWidth(200)
            if "pass" in name:
                edit.setEchoMode(QLineEdit.Password)
            g2_layout.addWidget(edit, i, 1)
            setattr(self, f"_edit_{name}", edit)

        btn_row2 = QHBoxLayout()
        b3 = QPushButton("查询")
        b3.clicked.connect(self._query_iot_net)
        b4 = QPushButton("设置")
        b4.clicked.connect(self._set_iot_net)
        btn_row2.addWidget(b3)
        btn_row2.addWidget(b4)
        btn_row2.addStretch()
        g2_layout.addLayout(btn_row2, len(fields_iot), 0, 1, 2)
        layout.addWidget(g2)

        # -- Topic --
        g3 = QGroupBox("IoT Topic 配置")
        g3_layout = QGridLayout(g3)
        self._chk_cid = QCheckBox("Client ID 启用")
        self._chk_cid.setChecked(True)
        g3_layout.addWidget(self._chk_cid, 0, 0, 1, 2)

        g3_layout.addWidget(QLabel("Topic 发布:"), 1, 0)
        self._edit_topic_pub = QLineEdit()
        self._edit_topic_pub.setMinimumWidth(250)
        g3_layout.addWidget(self._edit_topic_pub, 1, 1)

        g3_layout.addWidget(QLabel("Topic 订阅:"), 2, 0)
        self._edit_topic_sub = QLineEdit()
        g3_layout.addWidget(self._edit_topic_sub, 2, 1)

        btn_row3 = QHBoxLayout()
        b5 = QPushButton("查询")
        b5.clicked.connect(self._query_iot_topic)
        b6 = QPushButton("设置")
        b6.clicked.connect(self._set_iot_topic)
        btn_row3.addWidget(b5)
        btn_row3.addWidget(b6)
        btn_row3.addStretch()
        g3_layout.addLayout(btn_row3, 3, 0, 1, 2)
        layout.addWidget(g3)

        # -- 控制 --
        g4 = QGroupBox("控制命令")
        g4_layout = QGridLayout(g4)
        g4_layout.addWidget(QLabel("密码:"), 0, 0)
        self._edit_pwd = QLineEdit()
        self._edit_pwd.setMaximumWidth(100)
        self._edit_pwd.setEchoMode(QLineEdit.Password)
        g4_layout.addWidget(self._edit_pwd, 0, 1)
        g4_layout.addWidget(QLabel("新密码:"), 0, 2)
        self._edit_new_pwd = QLineEdit()
        self._edit_new_pwd.setMaximumWidth(100)
        self._edit_new_pwd.setEchoMode(QLineEdit.Password)
        g4_layout.addWidget(self._edit_new_pwd, 0, 3)

        btn_row4 = QHBoxLayout()
        for label, slot in [
            ("验证密码", self._do_pwd_verify), ("设置密码", self._do_pwd_set),
            ("出厂初始化", self._do_factory_reset), ("设备复位", self._do_device_reset),
        ]:
            btn = QPushButton(label)
            btn.clicked.connect(slot)
            btn_row4.addWidget(btn)
        btn_row4.addStretch()
        g4_layout.addLayout(btn_row4, 1, 0, 1, 4)
        layout.addWidget(g4)

        # -- 主动上报 --
        g5 = QGroupBox("主动上报配置 (report_config)")
        g5_layout = QGridLayout(g5)

        g5_layout.addWidget(QLabel("传感器类型:"), 0, 0)
        self._edit_report_sensor_type = QSpinBox()
        self._edit_report_sensor_type.setRange(0, 255)
        self._edit_report_sensor_type.setValue(12)
        g5_layout.addWidget(self._edit_report_sensor_type, 0, 1)

        g5_layout.addWidget(QLabel("上报间隔(s):"), 0, 2)
        self._edit_report_interval = QSpinBox()
        self._edit_report_interval.setRange(0, 86400)
        self._edit_report_interval.setValue(5)
        g5_layout.addWidget(self._edit_report_interval, 0, 3)

        g5_layout.addWidget(QLabel("超时(ms):"), 0, 4)
        self._edit_report_timeout = QSpinBox()
        self._edit_report_timeout.setRange(0, 60000)
        g5_layout.addWidget(self._edit_report_timeout, 0, 5)

        self._chk_report_enable = QCheckBox("启用上报")
        self._chk_report_enable.setChecked(True)
        g5_layout.addWidget(self._chk_report_enable, 1, 0)

        self._chk_report_once = QCheckBox("单次上报")
        g5_layout.addWidget(self._chk_report_once, 1, 1)

        self._chk_report_env = QCheckBox("环境评估")
        g5_layout.addWidget(self._chk_report_env, 1, 2)

        self._chk_report_ack = QCheckBox("需应答")
        g5_layout.addWidget(self._chk_report_ack, 1, 3)

        btn_row5 = QHBoxLayout()
        b7 = QPushButton("查询")
        b7.clicked.connect(self._query_report_config)
        b8 = QPushButton("设置")
        b8.clicked.connect(self._set_report_config)
        btn_row5.addWidget(b7)
        btn_row5.addWidget(b8)
        btn_row5.addStretch()
        g5_layout.addLayout(btn_row5, 2, 0, 1, 6)
        layout.addWidget(g5)

        layout.addStretch()
        return w

    def _build_data_tab(self) -> QWidget:
        w = QWidget()
        layout = QVBoxLayout(w)

        layout.addWidget(QLabel("<b>线圈传感数据 (loop_data)</b>"))
        self._loop_text = QTextEdit()
        self._loop_text.setReadOnly(True)
        self._loop_text.setFont(QFont("Consolas", 10))
        layout.addWidget(self._loop_text, 2)

        layout.addWidget(QLabel("<b>事件上报 (event_report)</b>"))
        self._event_text = QTextEdit()
        self._event_text.setReadOnly(True)
        self._event_text.setFont(QFont("Consolas", 10))
        layout.addWidget(self._event_text, 1)
        return w

    def _build_log_tab(self) -> QWidget:
        w = QWidget()
        layout = QVBoxLayout(w)
        self._log_text = QTextEdit()
        self._log_text.setReadOnly(True)
        self._log_text.setFont(QFont("Consolas", 9))
        layout.addWidget(self._log_text, 1)

        btn_clear = QPushButton("清空")
        btn_clear.clicked.connect(self._log_text.clear)
        layout2 = QHBoxLayout()
        layout2.addStretch()
        layout2.addWidget(btn_clear)
        layout.addLayout(layout2)
        return w

    # ================================================================
    # 模拟设备上报
    # ================================================================

    def _build_simulate_tab(self) -> QWidget:
        w = QWidget()
        layout = QVBoxLayout(w)

        # -- 设备序列码 --
        row1 = QHBoxLayout()
        row1.addWidget(QLabel("模拟设备 SN:"))
        self._sim_sn = QLineEdit("DC045A49718F")
        self._sim_sn.setMaximumWidth(160)
        row1.addWidget(self._sim_sn)
        row1.addStretch()
        layout.addLayout(row1)

        # -- loop_data --
        g1 = QGroupBox("线圈数据上报 (loop_data)")
        g1l = QVBoxLayout(g1)
        self._sim_loop = QPlainTextEdit()
        self._sim_loop.setFont(QFont("Consolas", 10))
        self._sim_loop.setMaximumBlockCount(2000)
        self._sim_loop.setPlainText(self._sample_loop_data())
        g1l.addWidget(self._sim_loop)
        btn_row1 = QHBoxLayout()
        btn_row1.addWidget(QLabel("上报间隔(s):"))
        self._sim_loop_interval = QSpinBox()
        self._sim_loop_interval.setRange(1, 3600)
        self._sim_loop_interval.setValue(5)
        btn_row1.addWidget(self._sim_loop_interval)
        b1 = QPushButton("发送一次")
        b1.clicked.connect(self._sim_send_loop)
        btn_row1.addWidget(b1)
        self._sim_loop_btn = QPushButton("开始周期上报")
        self._sim_loop_btn.setCheckable(True)
        self._sim_loop_btn.toggled.connect(self._sim_toggle_loop)
        btn_row1.addWidget(self._sim_loop_btn)
        btn_row1.addStretch()
        g1l.addLayout(btn_row1)
        layout.addWidget(g1)

        # -- event_report --
        g2 = QGroupBox("事件上报 (event_report)")
        g2l = QVBoxLayout(g2)
        self._sim_event = QPlainTextEdit()
        self._sim_event.setFont(QFont("Consolas", 10))
        self._sim_event.setPlainText(self._sample_event_data())
        g2l.addWidget(self._sim_event)
        g2l2 = QHBoxLayout()
        b2 = QPushButton("发送")
        b2.clicked.connect(self._sim_send_event)
        g2l2.addWidget(b2)
        g2l2.addStretch()
        g2l.addLayout(g2l2)
        layout.addWidget(g2)

        # -- heartbeat --
        g3 = QGroupBox("心跳上报 (heartbeat)")
        g3l = QVBoxLayout(g3)
        self._sim_hb = QPlainTextEdit()
        self._sim_hb.setFont(QFont("Consolas", 10))
        self._sim_hb.setPlainText(self._sample_heartbeat_data())
        g3l.addWidget(self._sim_hb)
        g3l2 = QHBoxLayout()
        g3l2.addWidget(QLabel("间隔(s):"))
        self._sim_hb_interval = QSpinBox()
        self._sim_hb_interval.setRange(5, 3600)
        self._sim_hb_interval.setValue(60)
        g3l2.addWidget(self._sim_hb_interval)
        b3 = QPushButton("发送一次")
        b3.clicked.connect(self._sim_send_hb)
        g3l2.addWidget(b3)
        self._sim_hb_btn = QPushButton("开始周期上报")
        self._sim_hb_btn.setCheckable(True)
        self._sim_hb_btn.toggled.connect(self._sim_toggle_hb)
        g3l2.addWidget(self._sim_hb_btn)
        g3l2.addStretch()
        g3l.addLayout(g3l2)
        layout.addWidget(g3)

        # timers
        self._sim_loop_timer = QTimer()
        self._sim_loop_timer.timeout.connect(self._sim_send_loop)
        self._sim_hb_timer = QTimer()
        self._sim_hb_timer.timeout.connect(self._sim_send_hb)

        return w

    def _sample_loop_data(self) -> str:
        return json.dumps({
            "msg_id": 100,
            "cmd": "loop_data",
            "ts": 1719000100,
            "data": {
                "channels": [
                    {"ch": 1, "level": "high", "iscar": False, "loop_ok": True,
                     "freq": 105280, "diff": 20, "sens": 7, "cndtn": 0,
                     "misc": {"type": "time", "value": 0}},
                    {"ch": 2, "level": "mid_high", "iscar": True, "loop_ok": True,
                     "freq": 98700, "diff": 1500, "sens": 7, "cndtn": 2,
                     "misc": {"type": "time", "value": 350}},
                ]
            }
        }, indent=2)

    def _sample_event_data(self) -> str:
        return json.dumps({
            "msg_id": 101,
            "cmd": "event_report",
            "ts": 1719000200,
            "data": {"events": [
                {"type": "car_enter", "ch": 2, "value": 0},
                {"type": "car_leave", "ch": 2, "value": 350},
            ]}
        }, indent=2)

    def _sample_heartbeat_data(self) -> str:
        return json.dumps({
            "msg_id": 200,
            "cmd": "heartbeat",
            "ts": 1719000060,
            "data": {"uptime": 3600, "loop_status": [True, True, False, True],
                     "net_status": True, "iot_status": True}
        }, indent=2)

    def _sim_publish(self, topic: str, text: str):
        if not self._mqtt.connected:
            QMessageBox.warning(self, "提示", "请先连接 MQTT Broker")
            return
        try:
            payload = json.loads(text)
            self._mqtt.publish(topic, payload, qos=1)
            self._log_send("[模拟]", topic, payload)
        except json.JSONDecodeError as e:
            QMessageBox.warning(self, "JSON 错误", str(e))
        except Exception as e:
            QMessageBox.critical(self, "发布失败", f"{type(e).__name__}: {e}")

    def _sim_send_loop(self):
        sn = self._sim_sn.text()
        self._sim_publish(topic_up(sn), self._sim_loop.toPlainText())

    def _sim_send_event(self):
        sn = self._sim_sn.text()
        self._sim_publish(topic_up(sn), self._sim_event.toPlainText())

    def _sim_send_hb(self):
        sn = self._sim_sn.text()
        self._sim_publish(topic_up(sn), self._sim_hb.toPlainText())

    def _sim_toggle_loop(self, checked: bool):
        if checked:
            self._sim_loop_timer.start(self._sim_loop_interval.value() * 1000)
            self._sim_loop_btn.setText("停止")
        else:
            self._sim_loop_timer.stop()
            self._sim_loop_btn.setText("开始周期上报")

    def _sim_toggle_hb(self, checked: bool):
        if checked:
            self._sim_hb_timer.start(self._sim_hb_interval.value() * 1000)
            self._sim_hb_btn.setText("停止")
        else:
            self._sim_hb_timer.stop()
            self._sim_hb_btn.setText("开始周期上报")

    # ================================================================
    # 协议 Topic 订阅/发布
    # ================================================================

    def _build_proto_topic_tab(self) -> QWidget:
        w = QWidget()
        layout = QVBoxLayout(w)

        row1 = QHBoxLayout()
        row1.addWidget(QLabel("设备 SN:"))
        self._proto_sn = QLineEdit()
        self._proto_sn.setMaximumWidth(150)
        self._proto_sn.textChanged.connect(self._refresh_proto_topics)
        row1.addWidget(self._proto_sn)
        row1.addStretch()
        layout.addLayout(row1)

        # 服务器下发 topics
        g1 = QGroupBox("服务器下发 Topic → 设备订阅（可发布）")
        self._proto_srv_tree = QTreeWidget()
        self._proto_srv_tree.setHeaderLabels(["Topic", "说明"])
        self._proto_srv_tree.setRootIsDecorated(False)
        self._proto_srv_tree.itemDoubleClicked.connect(self._proto_publish_item)
        g1l = QVBoxLayout(g1)
        g1l.addWidget(self._proto_srv_tree)
        layout.addWidget(g1)

        # 设备上报 topics
        g2 = QGroupBox("设备上报 Topic → 服务器订阅（可发布/订阅）")
        self._proto_dev_tree = QTreeWidget()
        self._proto_dev_tree.setHeaderLabels(["Topic", "说明"])
        self._proto_dev_tree.setRootIsDecorated(False)
        self._proto_dev_tree.itemDoubleClicked.connect(self._proto_publish_item)
        g2l = QVBoxLayout(g2)
        g2l.addWidget(self._proto_dev_tree)
        layout.addWidget(g2)

        # 发布载荷编辑
        g3 = QGroupBox("发布载荷 (JSON)")
        g3l = QVBoxLayout(g3)
        g3l2 = QHBoxLayout()
        g3l2.addWidget(QLabel("Topic:"))
        self._proto_pub_topic = QLineEdit()
        g3l2.addWidget(self._proto_pub_topic, 1)
        g3l.addLayout(g3l2)
        self._proto_payload = QPlainTextEdit()
        self._proto_payload.setFont(QFont("Consolas", 10))
        self._proto_payload.setMaximumBlockCount(1000)
        g3l.addWidget(self._proto_payload, 1)
        btn_row = QHBoxLayout()
        b1 = QPushButton("发布")
        b1.clicked.connect(self._proto_publish)
        btn_row.addWidget(b1)
        btn_row.addStretch()
        g3l.addLayout(btn_row)
        layout.addWidget(g3)

        return w

    def _refresh_proto_topics(self):
        sn = self._proto_sn.text().strip() or "{sn}"

        # 服务器下发 — 单主题
        srv = self._proto_srv_tree
        srv.clear()
        QTreeWidgetItem(srv, [topic_down(sn), "设备订阅此主题接收所有命令"])

        # 设备上报 — 单主题
        dev = self._proto_dev_tree
        dev.clear()
        item = QTreeWidgetItem(dev, [topic_up(sn), "设备发布：loop_data / event_report / heartbeat / 命令响应"])
        # 子条目列出 cmd 类型
        for cmd_name, desc in [
            ("loop_data", "线圈传感数据上报"),
            ("event_report", "事件上报（有车/无车/故障）"),
            ("heartbeat", "设备心跳"),
            ("响应", "各命令查询/设置响应（msg_id 匹配）"),
        ]:
            QTreeWidgetItem(item, [f"  cmd={cmd_name}", desc])

    def _proto_publish_item(self, item: QTreeWidgetItem, col: int):
        # 如果点中的是子条目（无有效 topic），取父条目的 topic
        topic = item.text(0)
        if item.parent() and not topic.startswith("dld960/"):
            topic = item.parent().text(0)
        self._proto_pub_topic.setText(topic)
        self._proto_payload.clear()
        self._notebook.setCurrentWidget(self._proto_payload.parent().parent())

    def _proto_publish(self):
        topic = self._proto_pub_topic.text()
        if not topic or not self._mqtt.connected:
            QMessageBox.warning(self, "提示", "请输入 Topic 并连接 Broker")
            return
        raw = self._proto_payload.toPlainText().strip()
        try:
            if raw:
                payload = json.loads(raw)
            else:
                payload = build_request(CMD_DEV_INFO_QUERY)
            self._mqtt.publish(topic, payload)
            self._log_send("[协议]", topic, payload)
        except json.JSONDecodeError as e:
            QMessageBox.warning(self, "JSON 错误", str(e))
        except Exception as e:
            QMessageBox.critical(self, "发布失败", f"{type(e).__name__}: {e}")

    # ================================================================
    # 自定义 Topic 订阅/发布
    # ================================================================

    def _build_custom_topic_tab(self) -> QWidget:
        w = QWidget()
        layout = QVBoxLayout(w)

        # 发布区
        g1 = QGroupBox("发布 (Publish)")
        g1l = QVBoxLayout(g1)

        row1 = QHBoxLayout()
        row1.addWidget(QLabel("Topic:"))
        self._custom_pub_topic = QLineEdit()
        row1.addWidget(self._custom_pub_topic, 1)
        g1l.addLayout(row1)

        row2 = QHBoxLayout()
        row2.addWidget(QLabel("QoS:"))
        self._custom_qos = QComboBox()
        self._custom_qos.addItems(["0", "1", "2"])
        self._custom_qos.setCurrentIndex(1)
        row2.addWidget(self._custom_qos)
        row2.addStretch()
        g1l.addLayout(row2)

        self._custom_payload = QPlainTextEdit()
        self._custom_payload.setFont(QFont("Consolas", 10))
        self._custom_payload.setMaximumBlockCount(2000)
        g1l.addWidget(self._custom_payload, 1)

        btn_pub = QPushButton("发布")
        btn_pub.clicked.connect(self._custom_publish)
        g1l.addWidget(btn_pub)
        layout.addWidget(g1)

        # 订阅区
        g2 = QGroupBox("订阅 (Subscribe) / 接收")
        g2l = QVBoxLayout(g2)

        row3 = QHBoxLayout()
        row3.addWidget(QLabel("Topic:"))
        self._custom_sub_topic = QLineEdit()
        row3.addWidget(self._custom_sub_topic, 1)
        row3.addWidget(QLabel("QoS:"))
        self._custom_sub_qos = QComboBox()
        self._custom_sub_qos.addItems(["0", "1", "2"])
        self._custom_sub_qos.setCurrentIndex(1)
        row3.addWidget(self._custom_sub_qos)
        btn_sub = QPushButton("订阅")
        btn_sub.clicked.connect(self._custom_subscribe)
        row3.addWidget(btn_sub)
        g2l.addLayout(row3)

        # 已订阅列表 + 接收消息
        self._custom_sub_list = QTreeWidget()
        self._custom_sub_list.setHeaderLabels(["已订阅 Topic", "QoS"])
        self._custom_sub_list.setRootIsDecorated(False)
        g2l.addWidget(self._custom_sub_list)

        self._custom_recv = QPlainTextEdit()
        self._custom_recv.setReadOnly(True)
        self._custom_recv.setFont(QFont("Consolas", 10))
        self._custom_recv.setMaximumBlockCount(2000)
        g2l.addWidget(self._custom_recv, 1)

        row4 = QHBoxLayout()
        btn_unsub = QPushButton("取消订阅")
        btn_unsub.clicked.connect(self._custom_unsubscribe)
        row4.addWidget(btn_unsub)
        row4.addStretch()
        btn_clear = QPushButton("清空接收")
        btn_clear.clicked.connect(self._custom_recv.clear)
        row4.addWidget(btn_clear)
        g2l.addLayout(row4)

        layout.addWidget(g2)

        # 保存自定义订阅列表，用于消息分发
        self._custom_subs: dict[str, int] = {}

        return w

    def _custom_publish(self):
        if not self._mqtt.connected:
            QMessageBox.warning(self, "提示", "请先连接 Broker")
            return
        topic = self._custom_pub_topic.text()
        if not topic:
            return
        raw = self._custom_payload.toPlainText().strip()
        try:
            payload = json.loads(raw) if raw else {}
            qos = int(self._custom_qos.currentText())
            self._mqtt.publish(topic, payload, qos=qos)
            self._log_send("[自定义]", topic, payload)
        except json.JSONDecodeError as e:
            QMessageBox.warning(self, "JSON 错误", str(e))
        except Exception as e:
            QMessageBox.critical(self, "发布失败", f"{type(e).__name__}: {e}")
            self._log(f"[自定义] 发布失败: {e}")

    def _custom_subscribe(self):
        if not self._mqtt.connected:
            QMessageBox.warning(self, "提示", "请先连接 Broker")
            return
        topic = self._custom_sub_topic.text()
        if not topic:
            return
        try:
            qos = int(self._custom_sub_qos.currentText())
            self._mqtt.subscribe(topic, qos=qos)
            self._custom_subs[topic] = qos
            # 更新列表
            found = False
            for i in range(self._custom_sub_list.topLevelItemCount()):
                item = self._custom_sub_list.topLevelItem(i)
                if item.text(0) == topic:
                    item.setText(1, str(qos))
                    found = True
                    break
            if not found:
                self._custom_sub_list.addTopLevelItem(QTreeWidgetItem([topic, str(qos)]))
            self._log(f"[订阅] {topic} (QoS={qos})")
        except Exception as e:
            QMessageBox.critical(self, "订阅失败", f"{type(e).__name__}: {e}")
            self._log(f"[订阅] 失败: {e}")

    def _custom_unsubscribe(self):
        items = self._custom_sub_list.selectedItems()
        if not items:
            return
        for item in items:
            topic = item.text(0)
            try:
                if topic in self._custom_subs:
                    self._mqtt.unsubscribe(topic)
                    del self._custom_subs[topic]
                idx = self._custom_sub_list.indexOfTopLevelItem(item)
                self._custom_sub_list.takeTopLevelItem(idx)
                self._log(f"[取消订阅] {topic}")
            except Exception as e:
                self._log(f"[取消订阅] 失败: {e}")

    # ================================================================
    # MQTT
    # ================================================================

    def _toggle_connect(self):
        if self._mqtt.connected:
            self._mqtt.disconnect()
        else:
            cfg = BrokerConfig(
                host=self._host_edit.text(),
                port=int(self._port_edit.text() or "1883"),
                username=self._user_edit.text(),
                password=self._pass_edit.text(),
            )
            self._mqtt.connect(cfg)
            self._log(f"正在连接 {cfg.host}:{cfg.port} ...")

    @Slot(bool, str)
    def _on_status(self, connected: bool, msg: str):
        if connected:
            self._btn_conn.setText("断开")
            self._status_label.setText("● 已连接")
            self._status_label.setStyleSheet("color: green; font-weight: bold;")
        else:
            self._btn_conn.setText("连接")
            self._status_label.setText("● 未连接")
            self._status_label.setStyleSheet("color: red; font-weight: bold;")
        self._log(msg)

    @Slot(str, str, object)
    def _on_message(self, topic: str, dev_serial: str, payload: dict):
        cmd = payload.get("cmd", "")
        ts = datetime.fromtimestamp(payload.get("ts", 0)).strftime("%H:%M:%S")

        # 响应类消息（含 code 字段）
        if "code" in payload:
            code = payload.get("code", -1)
            pmsg = payload.get("msg", "")
            data = payload.get("data", {})
            self._log_recv(topic, payload, f"{cmd} code={code} {pmsg}")
            if code == 0:
                if cmd == CMD_DEV_INFO_QUERY:
                    self._devmgr.update_from_dev_info(dev_serial, data)
                    self._show_json(data)
                elif cmd == CMD_SSC_NET_QUERY:
                    self._apply_ssc_net_data(data)
                elif cmd == CMD_IOT_NET_QUERY:
                    self._apply_iot_net_data(data)
                elif cmd == CMD_IOT_TOPIC_QUERY:
                    self._apply_iot_topic_data(data)
                elif cmd == CMD_LOOP_PARAM_QUERY:
                    self._show_json({cmd: data})
                elif cmd == CMD_REPORT_CONFIG:
                    self._apply_report_config_data(data)
            else:
                self._show_json({"error": f"code={code} {pmsg} ({ERROR_MSGS.get(code, '?')})"})

        elif cmd == CMD_LOOP_DATA:
            data = payload.get("data", {})
            self._devmgr.update_loop_data(dev_serial, data)
            chs = len(data.get("channels", []))
            self._log_recv(topic, payload, f"loop_data ({chs}ch)")
            self._append_text(self._loop_text, json.dumps(payload, indent=2, ensure_ascii=False))

        elif cmd == CMD_EVENT_REPORT:
            data = payload.get("data", {})
            self._devmgr.update_event(dev_serial, data)
            evt_count = len(data.get("events", []))
            self._log_recv(topic, payload, f"event ({evt_count} events)")
            self._append_text(self._event_text, json.dumps(payload, indent=2, ensure_ascii=False))

        elif cmd == CMD_HEARTBEAT:
            data = payload.get("data", {})
            self._devmgr.update_heartbeat(dev_serial, data)
            self._log_recv(topic, payload, f"heartbeat uptime={data.get('uptime', 0)}s")

        elif cmd == CMD_INITIALIZE:
            # V1.03: 设备上线初始化
            data = payload.get("data", {})
            dev_sn = data.get("dev_serial", dev_serial)
            extra = data.get("extra_info", {})
            self._devmgr.mark_online(dev_sn, extra)
            self._log_recv(topic, payload, f"initialize sn={dev_sn} ver={extra.get('version','?')}")
            self._show_json({"online": dev_sn, "info": extra})

        # 旧协议 / 无 cmd 字段 的消息（如 Initialize）
        elif "Method" in payload:
            self._log_recv(topic, payload, f"Method={payload.get('Method', '?')}")

        else:
            self._log_recv(topic, payload)

        # 自定义订阅消息 → 显示到自定义 Topic 接收区
        for sub_topic in self._custom_subs:
            if mqtt.topic_matches_sub(sub_topic, topic):
                self._append_custom_recv(topic, payload)
                break

    def _append_custom_recv(self, topic: str, payload: dict):
        ts = datetime.now().strftime("%H:%M:%S")
        text = f"--- {ts} ---\nTopic: {topic}\n{json.dumps(payload, indent=2, ensure_ascii=False)}\n"
        self._custom_recv.appendPlainText(text)
        self._custom_recv.moveCursor(QTextCursor.End)

    # ================================================================
    # 设备操作
    # ================================================================

    def _selected_dev(self) -> Optional[str]:
        items = self._dev_tree.selectedItems()
        return items[0].text(0).lstrip("●○ ") if items else None

    def _require_dev(self) -> Optional[str]:
        sn = self._selected_dev()
        if not sn:
            QMessageBox.warning(self, "提示", "请先选择一个设备")
            return None
        if not self._mqtt.connected:
            QMessageBox.warning(self, "提示", "请先连接 MQTT Broker")
            return None
        return sn

    def _send_cmd(self, cmd: str, data: Optional[dict] = None):
        sn = self._require_dev()
        if not sn:
            return
        try:
            mid = self._mqtt.send_command(sn, cmd, data)
            from dbn_mqtt_tool.protocol import build_request, get_topic_for_cmd
            msg = build_request(cmd, data)
            topic = get_topic_for_cmd(cmd, sn)
            self._log_send(f"[命令] {sn}", topic, msg)
        except Exception as e:
            QMessageBox.critical(self, "发送失败", str(e))

    def _query_dev_info(self):
        self._send_cmd(CMD_DEV_INFO_QUERY)

    def _query_all(self):
        sn = self._require_dev()
        if not sn:
            return
        for cmd in [CMD_DEV_INFO_QUERY, CMD_SSC_NET_QUERY, CMD_IOT_NET_QUERY,
                     CMD_IOT_TOPIC_QUERY, CMD_LOOP_PARAM_QUERY]:
            try:
                self._mqtt.send_command(sn, cmd)
            except Exception:
                pass

    def _query_ssc_net(self):
        self._send_cmd(CMD_SSC_NET_QUERY)

    def _set_ssc_net(self):
        self._send_cmd(CMD_SSC_NET_SET, data_ssc_net_set(
            dev_ip=self._edit_ssc_ip.text(),
            subnet_mask=self._edit_ssc_mask.text(),
            route_ip=self._edit_ssc_gw.text(),
            lssc_ip=self._edit_ssc_lssc.text(),
            dns=self._edit_ssc_dns.text(),
            port=int(self._edit_ssc_port.text() or "0"),
        ))

    def _query_iot_net(self):
        self._send_cmd(CMD_IOT_NET_QUERY)

    def _set_iot_net(self):
        self._send_cmd(CMD_IOT_NET_SET, data_iot_net_set(
            host=self._edit_iot_host.text(),
            port=int(self._edit_iot_port.text() or "1883"),
            client_id=self._edit_iot_cid.text(),
            username=self._edit_iot_user.text(),
            password=self._edit_iot_pass.text(),
        ))

    def _query_iot_topic(self):
        self._send_cmd(CMD_IOT_TOPIC_QUERY)

    def _set_iot_topic(self):
        self._send_cmd(CMD_IOT_TOPIC_SET, data_iot_topic_set(
            client_id_enable=self._chk_cid.isChecked(),
            topic_pub=self._edit_topic_pub.text(),
            topic_sub=self._edit_topic_sub.text(),
        ))

    def _apply_ssc_net_data(self, data: dict):
        self._edit_ssc_ip.setText(str(data.get("dev_ip", "")))
        self._edit_ssc_mask.setText(str(data.get("subnet_mask", "")))
        self._edit_ssc_gw.setText(str(data.get("route_ip", "")))
        self._edit_ssc_lssc.setText(str(data.get("lssc_ip", "")))
        self._edit_ssc_dns.setText(str(data.get("dns", "")))
        self._edit_ssc_port.setText(str(data.get("port", "")))

    def _apply_iot_net_data(self, data: dict):
        self._edit_iot_host.setText(str(data.get("host", "")))
        self._edit_iot_port.setText(str(data.get("port", "")))
        self._edit_iot_cid.setText(str(data.get("client_id", "")))
        self._edit_iot_user.setText(str(data.get("username", "")))
        self._edit_iot_pass.setText(str(data.get("password", "")))

    def _apply_iot_topic_data(self, data: dict):
        self._chk_cid.setChecked(bool(data.get("client_id_enable", True)))
        self._edit_topic_pub.setText(str(data.get("topic_pub", "")))
        self._edit_topic_sub.setText(str(data.get("topic_sub", "")))

    def _apply_report_config_data(self, data: dict):
        self._edit_report_sensor_type.setValue(int(data.get("sensor_type", 12)))
        self._edit_report_interval.setValue(int(data.get("interval", 5)))
        self._edit_report_timeout.setValue(int(data.get("timeout", 0)))
        self._chk_report_enable.setChecked(bool(data.get("enable", True)))
        self._chk_report_once.setChecked(bool(data.get("once", False)))
        self._chk_report_env.setChecked(bool(data.get("env_eval", False)))
        self._chk_report_ack.setChecked(bool(data.get("ack_required", False)))

    def _do_pwd_verify(self):
        pwd = self._edit_pwd.text()
        if not pwd:
            QMessageBox.warning(self, "提示", "请输入密码")
            return
        self._send_cmd(CMD_PWD_VERIFY, data_pwd_verify(pwd))

    def _do_pwd_set(self):
        old = self._edit_pwd.text()
        new = self._edit_new_pwd.text()
        if not old or not new:
            QMessageBox.warning(self, "提示", "请输入旧密码和新密码")
            return
        self._send_cmd(CMD_PWD_SET, data_pwd_set(old, new))

    def _do_factory_reset(self):
        r = QMessageBox.question(self, "确认", "确定要恢复出厂设置吗？\n此操作不可撤销！",
                                  QMessageBox.Yes | QMessageBox.No)
        if r == QMessageBox.Yes:
            self._send_cmd(CMD_FACTORY_RESET)

    def _do_device_reset(self):
        r = QMessageBox.question(self, "确认", "确定要复位设备吗？设备将重启。",
                                  QMessageBox.Yes | QMessageBox.No)
        if r == QMessageBox.Yes:
            self._send_cmd(CMD_DEVICE_RESET)

    def _query_report_config(self):
        self._send_cmd(CMD_REPORT_CONFIG)

    def _set_report_config(self):
        self._send_cmd(CMD_REPORT_CONFIG, data_report_config(
            sensor_type=self._edit_report_sensor_type.value(),
            enable=self._chk_report_enable.isChecked(),
            once=self._chk_report_once.isChecked(),
            env_eval=self._chk_report_env.isChecked(),
            interval=self._edit_report_interval.value(),
            ack_required=self._chk_report_ack.isChecked(),
            timeout=self._edit_report_timeout.value(),
        ))

    # ================================================================
    # UI 更新
    # ================================================================

    @Slot()
    def _refresh_devices(self):
        tree = self._dev_tree
        existing = {}
        for i in range(tree.topLevelItemCount()):
            item = tree.topLevelItem(i)
            sn = item.text(0).lstrip("●○ ")
            existing[sn] = item

        for sn, dev in self._devmgr.devices.items():
            status = "●" if dev.online else "○"
            model = dev.model or "?"
            if sn in existing:
                existing[sn].setText(0, f"{status} {sn}")
                existing[sn].setText(1, model)
                del existing[sn]
            else:
                item = QTreeWidgetItem([f"{status} {sn}", model])
                tree.addTopLevelItem(item)

        for sn, item in existing.items():
            idx = tree.indexOfTopLevelItem(item)
            tree.takeTopLevelItem(idx)

    def _on_dev_select(self):
        sn = self._selected_dev()
        if sn and sn in self._devmgr.devices:
            dev = self._devmgr.devices[sn]
            info = {
                "dev_serial": dev.dev_serial,
                "model": dev.model,
                "hard_ver": dev.hard_ver,
                "soft_ver": dev.soft_ver,
                "product_code": dev.product_code,
                "net_enabled": dev.net_enabled,
                "iot_enabled": dev.iot_enabled,
                "bus": dev.bus,
                "online": dev.online,
                "last_seen": dev.last_seen.strftime("%Y-%m-%d %H:%M:%S") if dev.last_seen else "—",
            }
            self._show_json(info)

    def _show_json(self, data: dict):
        self._info_text.setPlainText(json.dumps(data, indent=2, ensure_ascii=False))

    def _append_text(self, widget: QTextEdit, text: str):
        ts = datetime.now().strftime("%H:%M:%S")
        widget.append(f"--- {ts} ---\n{text}\n")
        widget.moveCursor(QTextCursor.End)

    def _log(self, msg: str):
        ts = datetime.now().strftime("%H:%M:%S")
        self._log_text.append(f"[{ts}] {msg}")
        self._log_text.moveCursor(QTextCursor.End)

    # ---- 详细收发日志 ----

    def _log_send(self, label: str, topic: str, payload: dict):
        """记录发送消息: 标签 + topic + 精简 payload"""
        payload_str = json.dumps(payload, ensure_ascii=False)
        if len(payload_str) > 200:
            payload_str = payload_str[:200] + "..."
        self._log(f"{label} → {topic}")
        self._log(f"       PASTE: {payload_str}")

    def _log_recv(self, topic: str, payload: dict, summary: str = ""):
        """记录接收消息: topic + summary + 精简 payload"""
        payload_str = json.dumps(payload, ensure_ascii=False)
        if len(payload_str) > 300:
            payload_str = payload_str[:300] + "..."
        self._log(f"← {topic}{' ' + summary if summary else ''}")
        self._log(f"       RECV: {payload_str}")


def main():
    app = QApplication(sys.argv)
    app.setStyle("Fusion")
    win = MainWindow()
    win.show()
    sys.exit(app.exec())


if __name__ == "__main__":
    main()