dzxj_dtu/backend/app.py

from flask import Flask, jsonify, request, abort, send_from_directory
from flask_cors import CORS
from flask_socketio import SocketIO, emit
import threading
import queue
import time
import json
import os
import re
import logging
import uuid

# 配置文件路径
SERIAL_CONFIG_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'serial_config.json')
MQTT_CONFIG_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'mqtt_config.json')

# 静态文件目录（前端构建产物或由 nginx 提供）
STATIC_FOLDER = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'frontend', 'dist')

# 导入配置
from config import (
    MAX_BUFFER_SIZE,
    FLASK_SECRET_KEY,
    FLASK_DEBUG,
    FLASK_HOST,
    FLASK_PORT,
    LOG_LEVEL,
    LOG_FORMAT,
    LOG_FILE,
    SOCKETIO_ASYNC_MODE,
    SOCKETIO_ALLOWED_ORIGINS,
    DEFAULT_FORWARD_SERIAL_TO_MQTT,
    DEFAULT_FORWARD_MQTT_TO_SERIAL,
    DEFAULT_MQTT_PUBLISH_TOPIC,
    SOCKETIO_NAMESPACE_DATA,
    SOCKETIO_NAMESPACE_STATUS,
    SOCKETIO_NAMESPACE_CONTROL,
    ERROR_CODES,
    ERROR_MESSAGES,
    DEFAULT_CUSTOMER_ID,
    DEFAULT_DTU_ID,
    DTU_HEARTBEAT_INTERVAL,
    DTU_OFFLINE_TIMEOUT,
    DEFAULT_MQTT_TOPIC_PREFIX,
    DTU_REGISTRATION_TOPIC,
    DTU_STATUS_TOPIC,
    DTU_CONTROL_TOPIC,
    DTU_RESPONSE_TOPIC,
    DTU_EVENT_TOPIC,
    DTU_ALARM_TOPIC,
    DTU_BROADCAST_TOPIC,
    MAX_PANELS,
    MAX_PORTS_PER_PANEL,
    DEFAULT_ADDRESS_RANGE,
    DEFAULT_UNBOUND_PROBE_BATCH,
    PANEL_MISS_THRESHOLD,
    PANEL_PROBE_TIMEOUT,
    DHT11_ENABLED,
    DHT11_GPIO_PIN,
    DHT11_GPIO_CHIP,
    DHT11_POLL_INTERVAL,
    DHT11_SIMULATE,
    NEXTION_ENABLED,
    NEXTION_SCREEN_PORT,
    NEXTION_SCREEN_BAUD,
    NEXTION_PANEL_NAME_PREFIX,
    NEXTION_CMD_DELAY_MS
)

# 配置日志
logging_config = {
    'level': getattr(logging, LOG_LEVEL),
    'format': LOG_FORMAT
}
if LOG_FILE:
    logging_config['filename'] = LOG_FILE

logging.basicConfig(**logging_config)
logger = logging.getLogger('serial_mqtt_gateway')

_boot_time = time.time()

from modules.serial_port import SerialPort
from modules.mqtt_client import MQTTClient
from modules.network_config import network_manager
from modules.modbus_rtu import ModbusRTUClient, ANTENNA_ADDRESSES, AddressConfigProtocol, build_confirm_address, calculate_crc16
from modules.dht11_sensor import DHT11Sensor
from modules.nextion_display import NextionDisplay
from modules import config_backup

app = Flask(__name__)

app.config['SECRET_KEY'] = FLASK_SECRET_KEY
# 配置CORS以允许nginx代理的前端访问
CORS(app, resources={r"/api/*": {"origins": "*"}, r"/socket.io/*": {"origins": "*"}})

# 初始化SocketIO
socketio = SocketIO(
    app, 
    cors_allowed_origins=SOCKETIO_ALLOWED_ORIGINS, 
    async_mode=SOCKETIO_ASYNC_MODE,
    manage_session=False,  # 禁用会话管理以提高性能
    ping_timeout=30,  # 心跳超时时间
    ping_interval=25,  # 心跳间隔
    logger=FLASK_DEBUG,  # 根据Flask调试模式决定是否记录SocketIO日志
    engineio_logger=FLASK_DEBUG
)

# 初始化串口和MQTT客户端
serial_client = SerialPort()
mqtt_client = MQTTClient()
modbus_client = ModbusRTUClient(serial_client)
address_config = AddressConfigProtocol(serial_client)

# Nextion 串口屏实例
screen_display = NextionDisplay()
screen_current_panel_index = 0
screen_lock = threading.Lock()
screen_refresh_queue = queue.Queue()
screen_refresh_thread = None

# 初始化 DHT11 传感器（后续在 __main__ 中设置回调并启动）
dht11_sensor = None
if DHT11_ENABLED and (DHT11_GPIO_PIN is not None or DHT11_SIMULATE):
    dht11_sensor = DHT11Sensor(
        gpio_pin=DHT11_GPIO_PIN,
        gpio_chip=DHT11_GPIO_CHIP,
        poll_interval=DHT11_POLL_INTERVAL,
        simulate=DHT11_SIMULATE
    )
elif DHT11_ENABLED and DHT11_GPIO_PIN is None and not DHT11_SIMULATE:
    logger.warning("DHT11 已启用但未配置 GPIO pin (DHT11_GPIO_PIN)，跳过本地传感器启动")

# 转发标志
forward_serial_to_mqtt = DEFAULT_FORWARD_SERIAL_TO_MQTT
forward_mqtt_to_serial = DEFAULT_FORWARD_MQTT_TO_SERIAL
mqtt_publish_topic = DEFAULT_MQTT_PUBLISH_TOPIC

# DTU MQTT协议配置（运行时可修改）
dtu_config = {
    'topic_prefix': DEFAULT_MQTT_TOPIC_PREFIX,
    'customer_id': DEFAULT_CUSTOMER_ID,
    'dtu_id': DEFAULT_DTU_ID,
    'firmware_version': 'v1.0.0',
    'hardware_version': 'v1.0',
    'heartbeat_interval': DTU_HEARTBEAT_INTERVAL,
    'enabled': True,
    'address_range': dict(DEFAULT_ADDRESS_RANGE)
}

DTU_CONFIG_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'dtu_config.json')

# 本地自动快照目录（每次写配置前自动快照，可在"数据备份"页恢复）
BACKUP_DIR = config_backup.BACKUP_DIR


def _save_config_file(path, data, label):
    """快照 + 原子写 JSON 配置文件"""
    try:
        config_backup.snapshot_before_write(path, BACKUP_DIR)
        config_backup.write_json_atomic(path, data)
        return True
    except Exception as e:
        logger.error(f"保存{label}失败: {e}")
        return False


def load_dtu_config():
    global dtu_config
    try:
        if os.path.exists(DTU_CONFIG_FILE):
            saved = None
            try:
                saved = config_backup.read_json_file(DTU_CONFIG_FILE)
            except Exception as e:
                logger.warning(f"加载DTU配置失败: {e}，尝试回退快照")
                saved, snap = config_backup.latest_snapshot_content(DTU_CONFIG_FILE, BACKUP_DIR)
                if isinstance(saved, dict):
                    logger.warning(f"已从快照恢复DTU配置: {snap}")
            if isinstance(saved, dict):
                dtu_config.update(saved)
    except Exception as e:
        logger.warning(f"加载DTU配置失败: {e}")

def save_dtu_config():
    _save_config_file(DTU_CONFIG_FILE, dtu_config, 'DTU配置')

# 端口状态追踪（用于事件检测）
port_state = {}  # {panel_id: {port_id: {'last_uid': str, 'expected_uid': str, 'alarm_count': int}}}

# jumper_uid 十六进制字符集（大写）
_JUMPER_HEX = set('0123456789ABCDEF')


_mac_uid_prefix_cache = None  # 缓存 MAC 派生的前缀（稳定，避免每次发布都读 MAC）


def _read_mac_bytes():
    """读取本机真实 MAC 地址（6 字节），失败返回 None。

    优先用 uuid.getnode()；其 multicast 位为 1 时是随机生成而非真实硬件 MAC，
    改读 /sys/class/net（Linux）兜底。
    """
    try:
        node = uuid.getnode()
        # 第 9 位(0x010000000000)为 1 表示 multicast/随机 MAC，非真实硬件地址
        if node and not (node & 0x010000000000):
            return node.to_bytes(6, 'big')
    except Exception:
        pass
    try:
        net_dir = '/sys/class/net'
        if os.path.isdir(net_dir):
            for iface in sorted(os.listdir(net_dir)):
                if iface == 'lo':
                    continue
                path = os.path.join(net_dir, iface, 'address')
                if os.path.exists(path):
                    with open(path) as f:
                        mac_str = f.read().strip()
                    if re.match(r'^[0-9A-Fa-f]{2}(:[0-9A-Fa-f]{2}){5}$', mac_str):
                        return bytes(int(b, 16) for b in mac_str.split(':'))
    except Exception:
        pass
    return None


def _dtu_uid_prefix():
    """jumper_uid 前 4 位 DTU 号（4 位大写十六进制），从 MAC 派生保证多 DTU 唯一。

    适配规则: MQTT jumper_uid = 前 4 位 DTU 号 + 后 12 位硬件卡号（共 16 位）。
    优先级:
      1. dtu_config['uid_prefix'] 显式配置（4 位大写十六进制）
      2. 本机 MAC 地址的 CRC16（稳定、各 DTU 不同）
      3. 兜底: dtu_id 末尾数字
    """
    global _mac_uid_prefix_cache
    p = (dtu_config.get('uid_prefix') or '').strip().upper()
    if len(p) == 4 and all(c in _JUMPER_HEX for c in p):
        return p
    if _mac_uid_prefix_cache is None:
        mac = _read_mac_bytes()
        if mac:
            _mac_uid_prefix_cache = calculate_crc16(mac).hex().upper()
        else:
            m = re.search(r'(\d+)$', str(dtu_config.get('dtu_id') or ''))
            n = int(m.group(1)) if m else 0
            _mac_uid_prefix_cache = f'{n & 0xFFFF:04X}'
    return _mac_uid_prefix_cache


def _to_mqtt_jumper_uid(card_uid):
    """内部 12 位硬件卡号 -> MQTT 16 位 jumper_uid（前 4 位 DTU 号 + 后 12 位卡号）。

    None/空 -> None。硬件通信固定 6 字节(12 位)，仅在 MQTT 边界拼成 16 位。
    """
    if not card_uid:
        return None
    return _dtu_uid_prefix() + card_uid.upper()


def _from_mqtt_jumper_uid(value):
    """MQTT 16 位 jumper_uid -> 内部 12 位硬件卡号（剥前 4 位 DTU 号）。

    None/空 -> None；非 16 位大写十六进制 -> 抛 ValueError（由 SYNC 调用方拒绝）。
    """
    if value is None:
        return None
    if not isinstance(value, str):
        raise ValueError(f"jumper_uid 必须是字符串或 null，当前类型: {type(value).__name__}")
    v = value.strip().upper()
    if v == '':
        return None
    if len(v) != 16 or any(c not in _JUMPER_HEX for c in v):
        raise ValueError(f"jumper_uid 必须是 16 位大写十六进制或 null，当前: {value!r}")
    return v[4:]


def _to_internal_uid_lenient(value):
    """重建端口状态用：兼容历史持久化数据。

    16 位 -> 剥前 4 位得 12 位；12 位 -> 原样；None/空 -> None；非法 -> None。
    """
    if value is None:
        return None
    if not isinstance(value, str):
        return None
    v = value.strip().upper()
    if v == '':
        return None
    if len(v) == 16 and all(c in _JUMPER_HEX for c in v):
        return v[4:]
    if len(v) == 12 and all(c in _JUMPER_HEX for c in v):
        return v
    return None


def _build_card_mappings_for_panel(panel_id):
    """从 dtu_config port_mappings 构建该面板 24 路卡号映射，用于 V4 下发硬件。

    返回: {port_id(1-24): 'hex12' or None}
    未配置/非法的端口返回 None（set_card_mapping 内部填 0xFF*6 无卡标记）。
    """
    mappings = dtu_config.get('port_mappings', {}).get(panel_id, {})
    result = {}
    for port_id in range(1, 25):
        uid = mappings.get(str(port_id))
        result[port_id] = _to_internal_uid_lenient(uid)  # 非法/空 -> None
    return result


def get_sorted_panels():
    """按 position 排序返回 panel 列表。"""
    return sorted(panel_config.items(), key=lambda x: x[1].get('position', 0))


def _port_status_to_pic(port_state_entry):
    """将端口状态推导为 Nextion pic 编号。

    pic 映射（当前屏幕工程只有 pic 0-3，ILLEGAL_DISCONNECT 复用 pic=2 告警图）:
      0 = UNKNOWN (未轮询)
      1 = DISCONNECTED (正常空闲: 无期望且无卡)
      2 = 告警 (ILLEGAL_CONNECT 非法插入 + ILLEGAL_DISCONNECT 非法拔出)
      3 = CONNECTED (正常已连: 实际 == 期望)

    未来若 Nextion 工程增加 pic=4，将 ILLEGAL_DISCONNECT 单独改为 return 4。
    """
    if not port_state_entry:
        return 0
    last_uid = port_state_entry.get('last_uid')
    expected_uid = port_state_entry.get('expected_uid')
    last_polled = port_state_entry.get('last_polled_at')
    if not last_polled:
        return 0  # UNKNOWN
    if last_uid is None:
        return 2 if expected_uid else 1  # ILLEGAL_DISCONNECT 复用告警图 / DISCONNECTED
    if expected_uid and last_uid != expected_uid:
        return 2  # ILLEGAL_CONNECT
    return 3  # CONNECTED


def _get_display_ip():
    """获取用于屏幕显示的本机 IP 地址。

    优先选择 192.168.199.x 管理网段；其次选择物理网卡 eth*/en* 上的 IPv4；
    最后回退到任意非回环 IPv4 或静态配置 IP。
    """
    try:
        net_status = network_manager.get_network_status()
        interfaces = net_status.get('interfaces', {})

        # 1. 优先 192.168.199.x 管理网段
        for iface, data in interfaces.items():
            if iface in ('lo', 'docker0') or iface.startswith(('br-', 'veth')):
                continue
            for addr in data.get('ip_addresses', []):
                if addr.startswith('192.168.199.') and '.' in addr:
                    return addr

        # 2. 优先物理网卡 eth*/en*/wlan* 上的 IPv4
        physical_ips = []
        for iface, data in interfaces.items():
            if iface in ('lo', 'docker0') or iface.startswith(('br-', 'veth', 'docker')):
                continue
            if not (iface.startswith(('eth', 'en', 'wlan', 'wl')) or iface == 'end0'):
                continue
            for addr in data.get('ip_addresses', []):
                if '.' in addr and not addr.startswith('127.'):
                    physical_ips.append((iface, addr))
        # 优先有线接口
        for iface, addr in physical_ips:
            if iface.startswith(('eth', 'en', 'end')):
                return addr
        if physical_ips:
            return physical_ips[0][1]

        # 3. 任意非回环 IPv4
        for iface, data in interfaces.items():
            if iface in ('lo', 'docker0') or iface.startswith(('br-', 'veth')):
                continue
            for addr in data.get('ip_addresses', []):
                if '.' in addr and not addr.startswith('127.'):
                    return addr

        # 4. 回退：尝试网络配置中的静态 IP
        net_config = network_manager.get_network_config()
        static_ip = net_config.get('static_config', {}).get('ip_address')
        if static_ip:
            return static_ip
    except Exception as e:
        logger.warning(f"获取显示 IP 失败: {e}")
    return ''


_last_display_ip = None  # 上次写入屏幕的 IP，用于检测变化


def _network_ip_monitor_loop():
    """后台监测本机 IP 变化。

    插网线获取到 IP（或 IP 发生任何变化）时，及时刷新串口屏显示。
    复用 screen_refresh_queue 串行化下发，避免与其它刷新竞争。
    """
    global _last_display_ip
    while True:
        try:
            current_ip = _get_display_ip()
            if current_ip != _last_display_ip:
                logger.info(f"显示 IP 变化: {_last_display_ip!r} -> {current_ip!r}")
                _last_display_ip = current_ip
                if screen_display.get_status().get('connected'):
                    panels = get_sorted_panels()
                    if panels:
                        with screen_lock:
                            idx = screen_current_panel_index
                        if 0 <= idx < len(panels):
                            screen_refresh_queue.put((panels[idx][0],))
                    else:
                        # 没有配线架也要刷新 IP，避免屏幕停留在 HMI 默认文字
                        screen_refresh_queue.put((None,))
        except Exception as e:
            logger.error(f"网络 IP 监测异常: {e}")
        time.sleep(3)


def _screen_refresh_worker():
    """在后台线程中异步刷新 Nextion 屏幕。"""
    while True:
        try:
            item = screen_refresh_queue.get()
            if item is None:
                break
            panel_id = item[0]
            if panel_id is None:
                # 没有配线架时也要把 IP/状态刷到屏幕
                if screen_display.get_status().get('connected'):
                    _send_screen_header()
            else:
                refresh_screen_panel(panel_id)
        except Exception as e:
            logger.error(f"屏幕刷新工作线程异常: {e}")
        finally:
            try:
                screen_refresh_queue.task_done()
            except Exception:
                pass


def _send_screen_header(panel_name=None):
    """下发与具体 panel 无关的屏幕信息：本机 IP、终端名、版本、MQTT 状态。

    即使一个配线架都没发现（panel_count=0）也调用，否则屏幕会一直停留在
    HMI 工程的默认文字（例如默认占位 IP）。
    """
    online_count = sum(
        1 for pid, _ in get_sorted_panels()
        if device_last_seen.get(pid, 0) > time.time() - 60
    )
    mqtt_st = mqtt_client.get_status()
    mqtt_connected = mqtt_st.get('connected', False) if isinstance(mqtt_st, dict) else bool(mqtt_st)

    delay_ms = NEXTION_CMD_DELAY_MS
    if panel_name is None:
        panel_name = f'{NEXTION_PANEL_NAME_PREFIX}0'

    screen_display.send_cmd(f't2.txt="{panel_name}"', delay_ms=delay_ms)
    screen_display.send_cmd(f't1.txt="{_get_display_ip()}"', delay_ms=delay_ms)
    screen_display.send_cmd(f't4.txt="{dtu_config.get("firmware_version", "v1.0.0")}"', delay_ms=delay_ms)

    mqtt_str = '已连接' if mqtt_connected else '未连接'
    screen_display.send_cmd(f'g0.txt="MQTT：{mqtt_str} 当前终端数：{online_count}"', delay_ms=delay_ms)
    screen_display.send_cmd(f'g0.pco={0 if mqtt_connected else 63488}', delay_ms=delay_ms)


def refresh_screen_panel(panel_id):
    """将指定 panel 的数据下发到 Nextion 屏幕。"""
    global screen_current_panel_index
    with screen_lock:
        panels = get_sorted_panels()
        if not panels:
            return False, '没有可用的 panel'
        panel_ids = [p[0] for p in panels]
        if panel_id not in panel_ids:
            return False, f'panel 不存在: {panel_id}'
        if not screen_display.get_status().get('connected'):
            return False, '屏幕串口未连接'

        idx = panel_ids.index(panel_id)
        screen_current_panel_index = idx

        # 当前 panel 对应的设备地址
        device_address = panel_config.get(panel_id, {}).get('address', 1)

        _send_screen_header(panel_name=f'{NEXTION_PANEL_NAME_PREFIX}{idx + 1}')

        for port_id in range(1, 25):
            # 屏幕网口图片显示 LED：由端口真实连接状态推导(连接/断开/非法/未知)
            pic = _port_status_to_pic(port_state.get(panel_id, {}).get(port_id))
            cmd = f'p{port_id - 1}.pic={pic}'
            ok = screen_display.send_cmd(cmd, delay_ms=delay_ms)
            logger.info(f"[Nextion] panel={panel_id} addr={device_address} port={port_id} pic={pic} cmd={cmd} ok={ok}")

        logger.info(f"屏幕已刷新: {panel_id} (终端{idx + 1})")
        return True, '屏幕已刷新'


def switch_screen_panel(direction):
    """切换当前显示的 panel，跳过已标记离线的终端。

    离线终端不再占用屏幕：按"上一/下一终端"时自动落到下一台在线的设备，
    避免屏上长时间停留在空白面板上。若全部终端都离线，则退化为相邻切换，
    方便用户仍能浏览各终端的离线状态。
    """
    global screen_current_panel_index
    with screen_lock:
        panels = get_sorted_panels()
        if not panels:
            return False, '没有可用的 panel'
        n = len(panels)
        start = screen_current_panel_index
        idx = (start + direction) % n
        found = False
        while idx != start:
            if panels[idx][1].get('status') != 'offline':
                found = True
                break
            idx = (idx + direction) % n
        if not found:
            # 全部离线：仍然切换到相邻面板，让用户能浏览各终端
            idx = (start + direction) % n
        screen_current_panel_index = idx
        panel_id = panels[idx][0]
        logger.info(f'屏幕切换: 终端{idx + 1} -> {panel_id}')
    return refresh_screen_panel(panel_id)


def _refresh_current_screen_panel():
    """LED 等状态变化后，触发当前屏幕 panel 刷新。"""
    try:
        panels = get_sorted_panels()
        if not panels:
            return
        with screen_lock:
            idx = screen_current_panel_index
            if 0 <= idx < len(panels):
                panel_id = panels[idx][0]
                screen_refresh_queue.put((panel_id,))
    except Exception as e:
        logger.warning(f"触发屏幕刷新失败: {e}")


def screen_button_event_handler(page_id, comp_id, event):
    """处理屏幕按钮事件。"""
    if event != 0x01:
        return
    if page_id == 0x00 and comp_id == 0x05:
        logger.info('串口屏事件: 上一终端')
        switch_screen_panel(-1)
    elif page_id == 0x00 and comp_id == 0x06:
        logger.info('串口屏事件: 下一终端')
        switch_screen_panel(1)


# 面板配置（从地址配置模块加载）
panel_config = {}  # {panel_id: {'address': int, 'position': int, 'panel_uid': str}}

# 面板连续轮询失败计数（达到阈值后标记离线，并在后续轮次改用 uid=0 探测：换架接管/原架恢复）
panel_fail_count = {}  # {panel_id: int}

# 未绑定地址轮转探测游标（地址段扫描用，避免每轮全扫空地址）
_unbound_probe_cursor = None

# 手动"扫描新线架"后台任务状态
_panel_scan_state = {'running': False, 'found': [], 'started_at': None, 'finished_at': None, 'error': None}


def _address_range():
    """当前地址段 (start, end)，非法时回退默认值"""
    rng = dtu_config.get('address_range') or DEFAULT_ADDRESS_RANGE
    try:
        start = int(rng.get('start', DEFAULT_ADDRESS_RANGE['start']))
        end = int(rng.get('end', DEFAULT_ADDRESS_RANGE['end']))
    except Exception:
        start, end = DEFAULT_ADDRESS_RANGE['start'], DEFAULT_ADDRESS_RANGE['end']
    if not (1 <= start <= end <= 247):
        start, end = DEFAULT_ADDRESS_RANGE['start'], DEFAULT_ADDRESS_RANGE['end']
    return start, end


def _default_panel_id(addr):
    return f"PANEL_{dtu_config.get('dtu_id', 'DTU001')}_{addr}"


def _binding_uid_for_address(addr):
    """返回绑定到该地址的线架 UID（无绑定返回 None）"""
    for uid, a in address_config.get_stored_devices().items():
        if a == addr:
            return uid
    return None


def _panel_id_for_address(addr):
    """按地址找 panel_id（panel_config 优先，其次 panel_id_mapping，最后默认命名）"""
    for pid, cfg in panel_config.items():
        if cfg.get('address') == addr:
            return pid
    pm = dtu_config.get('panel_id_mapping', {}) or {}
    uid = _binding_uid_for_address(addr)
    custom = (pm.get(uid) if uid else None) or pm.get(addr)
    return str(custom) if custom else _default_panel_id(addr)


def _is_panel_custom_id(panel_id, addr):
    """panel_id 是否为 panel_id_mapping 自定义（区别于默认命名）"""
    return panel_id != _default_panel_id(addr)


def _ensure_panel_entry(panel_id, addr, uid, status='online'):
    panel_config[panel_id] = {
        'address': addr,
        'position': addr,
        'panel_uid': uid,
        'status': status,
    }


def _mark_panel_offline_once(panel_id, addr, cfg):
    """标记面板离线（只发布一次离线状态，清端口运行态）"""
    if cfg.get('status') == 'offline':
        return
    cfg['status'] = 'offline'
    port_state.pop(panel_id, None)
    logger.info(f"面板 {panel_id}(地址={addr}) 已标记离线")
    dtu_publish_panel_status(panel_id, addr, None, online=False)
    # 若该面板正显示在串口屏上，触发刷新使其显示离线(全灰)状态，避免残留旧画面
    _refresh_current_screen_panel()


def _handle_panel_read_failure(panel_id, addr, cfg):
    """面板读卡失败：累计 miss；达到阈值标记离线。

    返回 True 表示已进入"接管/恢复探测"阶段（后续轮次用 uid=0 探测该地址）。
    """
    panel_fail_count[panel_id] = panel_fail_count.get(panel_id, 0) + 1
    n = panel_fail_count[panel_id]
    if n < PANEL_MISS_THRESHOLD:
        logger.warning(f"面板 {panel_id}(地址={addr}) 轮询无响应，连续失败 {n} 次")
        return False
    if cfg.get('status') != 'offline':
        logger.warning(f"面板 {panel_id}(地址={addr}) 连续 {n} 次无响应，转入接管/恢复探测")
    _mark_panel_offline_once(panel_id, addr, cfg)
    return True


def _maybe_refresh_screen_panel(panel_id):
    """该面板若正显示在串口屏上，触发一次刷新"""
    try:
        panels = get_sorted_panels()
        trigger_panel_id = None
        with screen_lock:
            if panels and 0 <= screen_current_panel_index < len(panels) and panels[screen_current_panel_index][0] == panel_id:
                trigger_panel_id = panel_id
        if trigger_panel_id:
            screen_refresh_queue.put((trigger_panel_id,))
    except Exception as e:
        logger.error(f"刷新屏幕失败: {e}")


def _migrate_port_mappings(old_panel_id, new_panel_id):
    """线架地址变化时迁移端口期望映射（随 panel_id 一起搬到新地址下）"""
    pm = dtu_config.setdefault('port_mappings', {})
    if old_panel_id and old_panel_id != new_panel_id and old_panel_id in pm and new_panel_id not in pm:
        pm[new_panel_id] = pm.pop(old_panel_id)
        save_dtu_config()
        logger.info(f"端口映射已迁移: {old_panel_id} -> {new_panel_id}")


def _push_card_mappings_to_panel(panel_id, addr, reason=''):
    """把持久化的期望卡号下发到线架硬件（换架接管/新注册后恢复面板数据）"""
    try:
        mappings = _build_card_mappings_for_panel(panel_id)
        if not any(v for v in mappings.values()):
            return
        result = modbus_client.set_card_mapping(addr, mappings)
        if 'error' in result:
            logger.warning(f"{reason}下发卡号失败: 地址={addr}, {result.get('error')}")
        else:
            count = len([v for v in mappings.values() if v])
            logger.info(f"{reason}已向地址={addr} 下发 {count} 路卡号")
    except Exception as e:
        logger.error(f"{reason}下发卡号异常: 地址={addr}, {e}")


def _process_cards_result(panel_id, addr, result, silent=False):
    """处理一次成功的批量读卡结果：更新端口状态/事件/告警，返回 panel_ports（用于状态发布）

    silent=True 时只对齐端口状态（不发布事件/告警），用于换架接管后的静默重建。
    """
    panel_ports = []
    for card in result.get('cards', []):
        port_id = card['antenna']
        uid = card['card_str'].upper() if card.get('present') else ''
        if panel_id not in port_state:
            port_state[panel_id] = {}
        if port_id not in port_state[panel_id]:
            # 重建端口状态时，从持久化的期望映射回填 expected_uid（内部 12 位）。
            # 兼容历史脏数据：16 位剥前 4 位得 12 位；12 位原样；非法丢弃并告警。
            exp_uid = dtu_config.get('port_mappings', {}).get(panel_id, {}).get(str(port_id))
            norm = _to_internal_uid_lenient(exp_uid)
            if exp_uid and norm is None:
                logger.warning(f"面板{panel_id}端口{port_id} 持久化的 expected_uid 非法已丢弃: {exp_uid!r}")
            port_state[panel_id][port_id] = {
                'last_uid': None,
                'expected_uid': norm,
                'alarm_count': 0,
                'last_polled_at': int(time.time() * 1000)
            }
        ps = port_state[panel_id][port_id]
        ps['last_polled_at'] = int(time.time() * 1000)
        last_uid = ps.get('last_uid')

        if silent:
            ps['last_uid'] = uid or None
            ps['alarm_count'] = 0
        else:
            if uid and uid != last_uid:
                dtu_publish_event(panel_id, port_id, 'CONNECT' if not last_uid else 'MOVE', uid, last_uid)
                ps['last_uid'] = uid
            elif not uid and last_uid:
                dtu_publish_event(panel_id, port_id, 'DISCONNECT', None, last_uid)
                ps['last_uid'] = None

            ps_exp = ps.get('expected_uid')
            if dtu_config.get('alarm_enabled', True):
                if ps_exp and uid and uid != ps_exp:
                    ps['alarm_count'] = ps.get('alarm_count', 0) + 1
                    sev = 'CRITICAL' if ps['alarm_count'] >= 3 else 'WARNING'
                    dtu_publish_alarm(panel_id, port_id, 'ILLEGAL_CONNECT', ps_exp, uid, sev)
                elif ps_exp and not uid:
                    ps['alarm_count'] = ps.get('alarm_count', 0) + 1
                    sev = 'CRITICAL' if ps['alarm_count'] >= 3 else 'WARNING'
                    dtu_publish_alarm(panel_id, port_id, 'ILLEGAL_DISCONNECT', ps_exp, None, sev)
                elif ps_exp and uid == ps_exp:
                    ps['alarm_count'] = 0

        ps_exp = ps.get('expected_uid')
        if uid:
            port_status = 'ILLEGAL' if (ps_exp and uid != ps_exp) else 'CONNECTED'
        else:
            port_status = 'DISCONNECTED'
        panel_ports.append({'port_id': port_id, 'status': port_status, 'jumper_uid': uid or None})

        # V4: LED 由配线架自控，DTU 不再自动下发灯状态
    return panel_ports


def _handle_panel_read_success(panel_id, cfg, addr, result, silent=False):
    """一次成功读卡后的统一处理：端口状态 + 恢复在线 + 状态发布 + 屏幕刷新"""
    panel_ports = _process_cards_result(panel_id, addr, result, silent=silent)
    if not silent and (cfg.get('status') == 'offline' or panel_fail_count.get(panel_id, 0) > 0):
        cfg['status'] = 'online'
        panel_fail_count.pop(panel_id, None)
        logger.info(f"面板 {panel_id}(地址={addr}) 恢复在线")
    device_last_seen[panel_id] = time.time()
    if cfg.get('panel_uid'):
        device_last_seen[cfg['panel_uid']] = time.time()
    dtu_publish_panel_status(panel_id, addr, panel_ports)
    _maybe_refresh_screen_panel(panel_id)


def _takeover_panel(panel_id, addr, old_uid, new_uid, result):
    """换架自动接管：新线架(UID 不同)出现在原地址 -> 绑定新 UID，继承原地址/映射/卡号数据"""
    old_uid = (old_uid or '').lower()
    new_uid = (new_uid or '').lower()
    stored = address_config.stored_devices
    if old_uid:
        stored.pop(old_uid, None)
    stored[new_uid] = addr
    save_device_config()

    cfg = panel_config.get(panel_id)
    if cfg is None:
        _ensure_panel_entry(panel_id, addr, new_uid)
        cfg = panel_config[panel_id]
    # 自定义 panel_id：换 UID 后仍保留原 panel_id（补一条 uid 映射，防止命名回退）
    if _is_panel_custom_id(panel_id, addr):
        dtu_config.setdefault('panel_id_mapping', {})[new_uid] = panel_id
        save_dtu_config()
    cfg['panel_uid'] = new_uid
    cfg['status'] = 'online'
    panel_fail_count.pop(panel_id, None)
    logger.info(f"线架自动接管: 地址={addr} 旧UID={old_uid or '未记录'} -> 新UID={new_uid}，继承原面板数据(端口映射不变)")

    # 端口状态静默对齐（避免换架瞬间误报 CONNECT/MOVE 事件），再按期望映射下发卡号
    _handle_panel_read_success(panel_id, cfg, addr, result, silent=True)
    _push_card_mappings_to_panel(panel_id, addr, reason='换架接管后')
    try:
        dtu_register()
    except Exception as e:
        logger.warning(f"接管后注册上报失败: {e}")
    return True


def _register_new_panel(addr, uid, result):
    """未绑定地址探测到线架 -> 绑定 地址↔UID"""
    uid = (uid or '').lower()
    existing_addr = address_config.stored_devices.get(uid)
    if existing_addr is not None and existing_addr != addr:
        old_pid = _panel_id_for_address(existing_addr)
        old_cfg = panel_config.get(old_pid, {})
        if old_cfg.get('status') == 'offline' or panel_fail_count.get(old_pid, 0) > 0:
            # 线架被手动改址：迁移绑定并把端口映射数据带到新地址
            address_config.stored_devices.pop(uid, None)
            panel_config.pop(old_pid, None)
            port_state.pop(old_pid, None)
            panel_fail_count.pop(old_pid, None)
            _migrate_port_mappings(old_pid, _panel_id_for_address(addr))
            logger.info(f"线架地址变更: UID={uid} {existing_addr} -> {addr}，绑定与映射已迁移")
        else:
            logger.warning(f"地址 {addr} 探测到线架 {uid}，但其仍绑定在地址 {existing_addr} 且在线，忽略本次绑定")
            return False

    address_config.stored_devices[uid] = addr
    save_device_config()
    panel_id = _panel_id_for_address(addr)
    if panel_id not in panel_config:
        _ensure_panel_entry(panel_id, addr, uid)
    logger.info(f"线架注册: 地址={addr} UID={uid}")
    _handle_panel_read_success(panel_id, panel_config[panel_id], addr, result)
    # 该地址若已有期望卡号（历史数据/恢复备份），一并下发到新线架
    _push_card_mappings_to_panel(panel_id, addr, reason='新线架注册后')
    try:
        dtu_register()
    except Exception as e:
        logger.warning(f"新线架注册后上报失败: {e}")
    return True


def _sweep_panel_addresses():
    """一轮地址段顺序扫描（注册模型核心）：

    - 已绑定且正常：带绑定 UID 读卡（读卡帧内含 UID，兼作线架保活）
    - 已绑定且失败过：改用 uid=0 探测 -> 同 UID=恢复在线；不同 UID=换架自动接管；无响应=继续缺失
    - 未绑定地址：仅当无面板处于缺失/接管状态时轮转抽查（uid=0 探测），
      未配置线架收到探测帧会采纳该地址并回的自身 UID，DTU 据此绑定
    所有总线帧仍走 serial_client 发送队列。
    """
    global _unbound_probe_cursor
    start, end = _address_range()
    stored = address_config.get_stored_devices()
    bound_map = {}
    for uid, a in stored.items():
        bound_map.setdefault(a, uid)

    # 任一绑定处于失败/缺失状态时暂停未绑定地址探测，避免新线架抢占非目标地址
    any_missing = any(panel_fail_count.get(_panel_id_for_address(a), 0) > 0 for a in bound_map)

    probe_set = set()
    if not any_missing:
        unbound = [a for a in range(start, end + 1) if a not in bound_map]
        if unbound:
            batch = dtu_config.get('unbound_probe_batch', DEFAULT_UNBOUND_PROBE_BATCH)
            try:
                batch = max(1, int(batch))
            except Exception:
                batch = DEFAULT_UNBOUND_PROBE_BATCH
            if _unbound_probe_cursor is None or not (start <= _unbound_probe_cursor <= end):
                _unbound_probe_cursor = start
            ordered = ([a for a in unbound if a >= _unbound_probe_cursor]
                       + [a for a in unbound if a < _unbound_probe_cursor])
            probe_set = set(ordered[:batch])
            _unbound_probe_cursor = (max(probe_set) + 1) if probe_set else start
            if _unbound_probe_cursor > end:
                _unbound_probe_cursor = start

    sweep_addrs = sorted(set(range(start, end + 1)) | set(bound_map.keys()))
    online = 0
    offline = 0
    for addr in sweep_addrs:
        uid = bound_map.get(addr)
        try:
            if not uid:
                # 未绑定地址：轮转抽查
                if addr in probe_set:
                    result = modbus_client.read_all_antenna_cards(addr, uid=None, timeout=PANEL_PROBE_TIMEOUT)
                    if 'error' not in result:
                        new_uid = (result.get('panel_uid') or '').lower()
                        if not new_uid:
                            logger.warning(f"地址 {addr} 探测有响应但未携带线架 UID（旧固件?），忽略绑定")
                        else:
                            _register_new_panel(addr, new_uid, result)
                continue

            panel_id = _panel_id_for_address(addr)
            cfg = panel_config.get(panel_id)
            if cfg is None:
                _ensure_panel_entry(panel_id, addr, uid)
                cfg = panel_config[panel_id]

            if panel_fail_count.get(panel_id, 0) == 0:
                # 正常轮次：带绑定 UID 读卡
                try:
                    uid_bytes = bytes.fromhex(uid)
                except ValueError:
                    uid_bytes = None
                if uid_bytes is None:
                    logger.error(f"地址 {addr} 绑定的 UID 非法: {uid!r}，跳过本轮")
                    continue
                result = modbus_client.read_all_antenna_cards(addr, uid=uid_bytes, timeout=1.0)
                if 'error' in result:
                    offline += 1
                    _handle_panel_read_failure(panel_id, addr, cfg)
                else:
                    online += 1
                    _handle_panel_read_success(panel_id, cfg, addr, result)
            else:
                # 缺失/接管探测轮次：uid=0 探测（原线架恢复或新线架换架接管）
                result = modbus_client.read_all_antenna_cards(addr, uid=None, timeout=PANEL_PROBE_TIMEOUT)
                if 'error' in result:
                    offline += 1
                    _handle_panel_read_failure(panel_id, addr, cfg)
                    continue
                resp_uid = (result.get('panel_uid') or '').lower()
                if not resp_uid:
                    # 旧固件无 UID 字段：无法校验，按原 UID 视作在线（过渡期）
                    logger.warning(f"地址 {addr} 探测响应无 UID（旧固件?），按原绑定 UID 视作在线")
                    online += 1
                    _handle_panel_read_success(panel_id, cfg, addr, result)
                elif resp_uid == uid.lower():
                    online += 1
                    _handle_panel_read_success(panel_id, cfg, addr, result)
                else:
                    _takeover_panel(panel_id, addr, uid, resp_uid, result)
                    online += 1
        finally:
            time.sleep(0.05)

    return online, offline

# 数据存储缓冲区
serial_data_buffer = []
mqtt_data_buffer = []

# 状态标志
serial_status = False
mqtt_status = False


# 辅助函数：统一处理 get_status() 返回 dict 的布尔判断
def _mqtt_connected():
    """MQTT 客户端是否已连接"""
    st = mqtt_client.get_status()
    return st.get('connected', False) if isinstance(st, dict) else bool(st)


def _serial_connected():
    """串口是否已连接"""
    st = serial_client.get_status()
    return st.get('connected', False) if isinstance(st, dict) else bool(st)


# 串口配置保存和加载函数
def save_serial_config(port, baudrate=9600, timeout=1.0, bytesize=8, parity='N', stopbits=1):
    """保存串口配置"""
    config = {
        'port': port,
        'baudrate': baudrate,
        'timeout': timeout,
        'bytesize': bytesize,
        'parity': parity,
        'stopbits': stopbits
    }
    if _save_config_file(SERIAL_CONFIG_FILE, config, '串口配置'):
        logger.info(f"串口配置已保存: {port} @ {baudrate}")

def load_serial_config():
    """加载串口配置（文件损坏时回退最新快照）"""
    if os.path.exists(SERIAL_CONFIG_FILE):
        try:
            try:
                config = config_backup.read_json_file(SERIAL_CONFIG_FILE)
            except Exception as e:
                logger.error(f"加载串口配置失败: {e}，尝试回退快照")
                config, snap = config_backup.latest_snapshot_content(SERIAL_CONFIG_FILE, BACKUP_DIR)
                if not isinstance(config, dict):
                    return None
                logger.warning(f"已从快照恢复串口配置: {snap}")
            logger.info(f"已加载串口配置: {config.get('port')} @ {config.get('baudrate')}")
            return config
        except Exception as e:
            logger.error(f"加载串口配置失败: {e}")
    return None

def save_mqtt_config(broker, port=1883, client_id='', username='', password='', keepalive=60, topics=None):
    """保存MQTT配置"""
    config = {
        'broker': broker,
        'port': port,
        'client_id': client_id,
        'username': username,
        'password': password,
        'keepalive': keepalive,
        'topics': topics or []
    }
    if _save_config_file(MQTT_CONFIG_FILE, config, 'MQTT配置'):
        logger.info(f"MQTT配置已保存: {broker}:{port}")

def load_mqtt_config():
    """加载MQTT配置（文件损坏时回退最新快照）"""
    if os.path.exists(MQTT_CONFIG_FILE):
        try:
            try:
                config = config_backup.read_json_file(MQTT_CONFIG_FILE)
            except Exception as e:
                logger.error(f"加载MQTT配置失败: {e}，尝试回退快照")
                config, snap = config_backup.latest_snapshot_content(MQTT_CONFIG_FILE, BACKUP_DIR)
                if not isinstance(config, dict):
                    return None
                logger.warning(f"已从快照恢复MQTT配置: {snap}")
            logger.info(f"已加载MQTT配置: {config.get('broker')}:{config.get('port')}")
            return config
        except Exception as e:
            logger.error(f"加载MQTT配置失败: {e}")
    return None

def auto_connect_mqtt():
    """自动连接上次使用的MQTT服务器"""
    config = load_mqtt_config()
    if config and config.get('broker'):
        broker = config.get('broker')
        port = config.get('port', 1883)
        client_id = config.get('client_id', '')
        username = config.get('username', '')
        password = config.get('password', '')
        keepalive = config.get('keepalive', 60)
        topics = config.get('topics', [])
        
        logger.info(f"尝试自动连接MQTT: {broker}:{port}")
        will_topic = build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'status')
        will_payload = json.dumps({
            'dtu_id': dtu_config['dtu_id'], 'type': 'STATUS',
            'payload': {'online': False, 'reason': 'CONNECTION_LOST'}
        })
        success, message = mqtt_client.connect(
            broker=broker, port=port, client_id=client_id,
            username=username or "", password=password or "",
            keepalive=keepalive,
            will_topic=will_topic, will_payload=will_payload, will_qos=1, will_retain=False
        )
        if success:
            logger.info(f"自动连接MQTT成功: {broker}:{port}")
            if topics:
                mqtt_client.subscribe(topics)
        else:
            logger.warning(f"自动连接MQTT失败: {message}")
        return success
    return False

def auto_connect_serial():
    """自动连接上次使用的串口"""
    config = load_serial_config()
    if config and config.get('port'):
        port = config.get('port')
        baudrate = config.get('baudrate', 9600)
        timeout = config.get('timeout', 1.0)
        bytesize = config.get('bytesize', 8)
        parity = config.get('parity', 'N')
        stopbits = config.get('stopbits', 1)
        logger.info(f"尝试自动连接串口: {port} @ {baudrate}")
        success, message = serial_client.connect(port, baudrate=baudrate, timeout=timeout, bytesize=bytesize, parity=parity, stopbits=stopbits)
        if success:
            logger.info(f"自动连接串口成功: {port}")
            return True
        else:
            logger.warning(f"自动连接串口失败: {message}")
    return False

# 客户端连接管理
connected_clients = {
    'data': set(),
    'status': set(),
    'control': set()
}

# 设置回调函数
def serial_data_handler(data):
    """处理串口接收的数据"""
    try:
        timestamp = time.strftime('%Y-%m-%d %H:%M:%S')
        serial_data_buffer.append({
            'timestamp': timestamp,
            'data': data,
            'direction': 'in'
        })
        if len(serial_data_buffer) > MAX_BUFFER_SIZE:
            serial_data_buffer.pop(0)
        
        socketio.emit('serial_data', {
            'timestamp': timestamp,
            'data': data,
            'direction': 'in'
        }, namespace=SOCKETIO_NAMESPACE_DATA)
        
        if forward_serial_to_mqtt and _mqtt_connected():
            success, msg = mqtt_client.publish(mqtt_publish_topic, data)
            if not success:
                logger.warning(f"串口数据转发到MQTT失败: {msg}")
    except Exception as e:
        logger.error(f"处理串口数据时出错: {str(e)}")

def serial_send_handler(data):
    """处理串口发送的数据"""
    try:
        timestamp = time.strftime('%Y-%m-%d %H:%M:%S')
        serial_data_buffer.append({
            'timestamp': timestamp,
            'data': data,
            'direction': 'out'
        })
        if len(serial_data_buffer) > MAX_BUFFER_SIZE:
            serial_data_buffer.pop(0)
        
        socketio.emit('serial_data', {
            'timestamp': timestamp,
            'data': data,
            'direction': 'out'
        }, namespace=SOCKETIO_NAMESPACE_DATA)
    except Exception as e:
        logger.error(f"处理串口发送数据时出错: {str(e)}")

def serial_status_handler(status):
    """处理串口状态变化"""
    try:
        global serial_status
        serial_status = status

        # 通过WebSocket广播状态变化
        socketio.emit('serial_status', {
            'connected': status
        }, namespace=SOCKETIO_NAMESPACE_STATUS)

        logger.info(f"串口状态更新: {'已连接' if status else '已断开'}")

        # 串口重新连接后，按线架绑定表重建面板配置（实际在线状态由地址段扫描刷新）
        if status:
            try:
                sync_panel_config()
            except Exception as e:
                logger.error(f"串口重连后同步面板配置失败: {e}")
    except Exception as e:
        logger.error(f"处理串口状态时出错: {str(e)}")

def mqtt_data_handler(data):
    """处理MQTT接收的数据"""
    try:
        # 添加到缓冲区
        timestamp = time.strftime('%Y-%m-%d %H:%M:%S')
        mqtt_data_buffer.append({
            'timestamp': timestamp,
            'topic': data['topic'],
            'payload': data['payload']
        })
        # 保持缓冲区大小
        if len(mqtt_data_buffer) > MAX_BUFFER_SIZE:
            mqtt_data_buffer.pop(0)
        
        # 通过WebSocket广播数据
        socketio.emit('mqtt_data', {
            'timestamp': timestamp,
            'topic': data['topic'],
            'payload': data['payload']
        }, namespace=SOCKETIO_NAMESPACE_DATA)
        
        # 如果启用了转发且串口已连接，转发数据到串口
        if forward_mqtt_to_serial and _serial_connected():
            success, msg = serial_client.send_data(data['payload'])
            if not success:
                logger.warning(f"MQTT数据转发到串口失败: {msg}")
    except Exception as e:
        logger.error(f"处理MQTT数据时出错: {str(e)}")

def mqtt_status_handler(status):
    """处理MQTT状态变化"""
    try:
        global mqtt_status
        mqtt_status = status

        # 通过WebSocket广播状态变化
        socketio.emit('mqtt_status', {
            'connected': status
        }, namespace=SOCKETIO_NAMESPACE_STATUS)

        logger.info(f"MQTT状态更新: {'已连接' if status else '已断开'}")

        # 如果MQTT连接成功且启用了DTU协议，发送注册消息和订阅控制主题
        if status and dtu_config.get('enabled'):
            socketio.sleep(1)  # 等待连接稳定

            # 发送DTU注册消息
            dtu_register()

            # 订阅控制主题
            control_topic = build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'control')
            mqtt_client.subscribe(control_topic, qos=1)
            logger.info(f"已订阅控制主题: {control_topic}")

            # 订阅广播主题 (DTU发现 7.14 和批量配置 7.15)
            discover_topic = build_dtu_topic('broadcast', 'dtu', 'discover')
            config_topic = build_dtu_topic('broadcast', 'dtu', 'config')
            mqtt_client.subscribe(discover_topic, qos=1)
            mqtt_client.subscribe(config_topic, qos=1)
            logger.info(f"已订阅广播主题: {discover_topic}, {config_topic}")

            # MQTT 状态变化时刷新当前屏幕显示
            panels = get_sorted_panels()
            if screen_display.get_status().get('connected'):
                try:
                    if panels:
                        with screen_lock:
                            current_idx = screen_current_panel_index
                        if 0 <= current_idx < len(panels):
                            screen_refresh_queue.put((panels[current_idx][0],))
                    else:
                        screen_refresh_queue.put((None,))
                except Exception as e:
                    logger.error(f"MQTT 状态变化刷新屏幕失败: {e}")
    except Exception as e:
        logger.error(f"处理MQTT状态时出错: {str(e)}")


# ========== DTU MQTT协议处理函数 ==========

def build_dtu_topic(*parts):
    """构建DTU MQTT主题"""
    prefix = dtu_config.get('topic_prefix', '线架系统')
    return '/'.join([prefix] + list(parts))


def dtu_register(discovery_request_id=None):
    """发送DTU注册消息"""
    if not _mqtt_connected():
        logger.warning("MQTT未连接，无法发送注册消息")
        return False

    try:
        # 加载面板配置
        devices = address_config.get_stored_devices()
        # 优先使用 dtu_config 中预设的 panel_id 映射 (uid_hex -> panel_id)
        panel_id_map = dtu_config.get('panel_id_mapping', {}) or {}
        panels = []
        panel_id = 1
        for uid_hex, addr in devices.items():
            custom_id = panel_id_map.get(uid_hex) or panel_id_map.get(addr)
            if custom_id:
                pid = str(custom_id)
            else:
                pid = f"PANEL_{dtu_config['dtu_id']}_{addr}"
            panels.append({
                'panel_id': pid,
                'address': addr,
                'position': panel_id,
                'panel_uid': uid_hex
            })
            panel_id += 1

        # 检测网络类型
        network_type = 'ethernet'
        signal_strength = None
        try:
            interfaces = network_manager.get_network_status().get('interfaces', {})
            for name, info in interfaces.items():
                if name in ('lo', 'docker0') or name.startswith(('br-', 'veth')):
                    continue
                if info.get('status') != 'UP':
                    continue
                if name.startswith(('wlan', 'wlp')):
                    network_type = 'wifi'
                    # 读取信号强度 (dBm, 越接近 0 越强)
                    try:
                        import re
                        with open('/proc/net/wireless') as f:
                            for line in f.readlines()[2:]:
                                m = re.match(r'\s*(\S+):.*\s(\d+)\.\s+(-?\d+)\.', line)
                                if m:
                                    signal_strength = int(m.group(3))
                                    break
                    except Exception:
                        pass
                elif name.startswith(('wwan', 'ppp', 'usb', 'eth')):
                    # 移动网卡
                    if name.startswith(('wwan', 'ppp', 'usb')):
                        network_type = 'cellular'
                break
        except Exception:
            pass

        payload = {
            'msg_id': f"reg_{int(time.time() * 1000)}_{uuid.uuid4().hex[:6]}",
            'timestamp': int(time.time() * 1000),
            'dtu_id': dtu_config['dtu_id'],
            'type': 'REGISTER',
            'payload': {
                'firmware_version': dtu_config.get('firmware_version', 'v1.0.0'),
                'hardware_version': dtu_config.get('hardware_version', 'v1.0'),
                'panel_count': len(panels),
                'network_type': network_type,
                'signal_strength': signal_strength,
                'uptime': int((time.time() - _boot_time) * 1000),
                'panels': panels,
                'discovery_request_id': discovery_request_id
            }
        }

        if discovery_request_id:
            payload['payload']['discovery_request_id'] = discovery_request_id

        topic = build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'register')
        success, msg = mqtt_client.publish(topic, json.dumps(payload), qos=1)

        if success:
            logger.info(f"DTU注册消息已发送: {topic}")
        else:
            logger.error(f"DTU注册消息发送失败: {msg}")

        return success
    except Exception as e:
        logger.error(f"发送DTU注册消息失败: {str(e)}")
        return False


_discover_dedup = {}

def handle_broadcast_discover(payload):
    """处理广播发现消息 (7.14)"""
    try:
        if not isinstance(payload, dict) or payload.get('type') != 'DISCOVER':
            return

        p = payload.get('payload', {})
        cust_id = p.get('customer_id', '')
        if cust_id and cust_id != dtu_config.get('customer_id'):
            return

        request_id = p.get('request_id', '')
        now = time.time()
        if request_id and request_id in _discover_dedup:
            if now - _discover_dedup[request_id] < 60:
                return
        _discover_dedup[request_id] = now
        # 清理超过 60s 的旧条目，防止内存泄漏
        if len(_discover_dedup) > 256:
            for k in list(_discover_dedup.keys()):
                if now - _discover_dedup[k] > 60:
                    _discover_dedup.pop(k, None)

        logger.info(f"收到DISCOVER广播，响应注册消息 (request_id={request_id})")
        import random
        delay = random.uniform(0, 3.0)
        time.sleep(delay)

        dtu_register(discovery_request_id=request_id)
        dtu_publish_status()
    except Exception as e:
        logger.error(f"处理广播发现消息失败: {str(e)}")


def handle_broadcast_config(payload):
    """处理广播批量配置消息 (7.15)"""
    try:
        if isinstance(payload, dict) and payload.get('type') == 'CONFIG':
            cfg = payload.get('payload', {})
            cust_id = cfg.get('customer_id', '')
            if cust_id and cust_id != dtu_config.get('customer_id'):
                return

            config_version = cfg.get('config_version', '')
            force_apply = cfg.get('force_apply', False)
            items = cfg.get('items', {})

            local_version = dtu_config.get('config_version', '')
            incoming_msg_id = payload.get('msg_id', '')
            if local_version == config_version and not force_apply:
                logger.info(f"配置版本 {config_version} 已存在，跳过")
                _send_config_response(config_version, [], True, 1011, incoming_msg_id)
                return

            valid_ranges = {
                'heartbeat_interval': (10, 3600),
                'poll_interval_ms': (100, 10000),
                'modbus_timeout_ms': (200, 5000),
                'mqtt_keepalive': (10, 300),
                'event_debounce_ms': (0, 5000),
            }
            applied = []
            for key, val in items.items():
                if key in valid_ranges:
                    lo, hi = valid_ranges[key]
                    if not (lo <= val <= hi):
                        _send_config_response(config_version, applied, False, 1012, incoming_msg_id)
                        return
                    if key == 'heartbeat_interval':
                        dtu_config['heartbeat_interval'] = val
                    elif key == 'mqtt_keepalive':
                        dtu_config['mqtt_keepalive'] = val
                    elif key == 'event_debounce_ms':
                        dtu_config['event_debounce_ms'] = val
                    elif key == 'poll_interval_ms':
                        dtu_config['poll_interval_ms'] = val
                    elif key == 'modbus_timeout_ms':
                        dtu_config['modbus_timeout_ms'] = val
                    applied.append(key)
                elif key in ('alarm_enabled',):
                    dtu_config['alarm_enabled'] = bool(val)
                    applied.append(key)
                else:
                    _send_config_response(config_version, applied, False, 1013, incoming_msg_id)
                    return

            if applied:
                dtu_config['config_version'] = config_version
                try:
                    save_dtu_config()
                except Exception as e:
                    logger.error(f"配置写入持久化失败: {e}")
                    _send_config_response(config_version, applied, False, 1014, incoming_msg_id)
                    return

            _send_config_response(config_version, applied, True, 0, incoming_msg_id)

    except Exception as e:
        logger.error(f"处理广播配置消息失败: {str(e)}")


def _send_config_response(config_version, applied_items, success, error_code, original_msg_id=''):
    """发送批量配置响应 (随机 0-2000ms 延迟避免广播风暴)"""
    import time as _t, json as _j, random as _r
    delay = _r.uniform(0, 2.0)

    def _delayed_publish():
        _t.sleep(delay)
        topic = build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'response')
        payload = {
            'msg_id': f"rsp_cfg_{int(_t.time() * 1000)}",
            'timestamp': int(_t.time() * 1000),
            'dtu_id': dtu_config['dtu_id'],
            'type': 'RESPONSE',
            'payload': {
                'original_msg_id': original_msg_id or f"cfg_{config_version}",
                'command': 'BROADCAST_CONFIG',
                'success': success,
                'result': {
                    'applied_version': config_version,
                    'applied_items': applied_items,
                    'restart_required': False
                } if success else None,
                'error_code': error_code,
                'error_message': get_ota_error_message(error_code) if error_code and error_code >= 1000 else None
            }
        }
        mqtt_client.publish(topic, _j.dumps(payload), qos=1)

    # 异步执行避免阻塞 MQTT 主循环
    threading.Thread(target=_delayed_publish, daemon=True).start()


def dtu_publish_status(force=False):
    """发送DTU状态/心跳消息

    Args:
        force: 保留参数。事件/告警/查询触发时传入 True，用于立即上报（区别于定时心跳）
    """
    if not _mqtt_connected() or not dtu_config.get('enabled'):
        return False
    # 调试日志: 区分定时 vs 触发上报
    if force:
        logger.debug("dtu_publish_status(force=True) - 事件触发立即上报")

    try:
        # panel_online 计数: 在最近 60s 内所有 24 个端口都被成功轮询过
        # 严格语义: 全部 24 端口在最近一轮 poll 周期内被 poll 成功 → online
        now_ms = int(time.time() * 1000)
        threshold_ms = 60_000  # 60 秒未轮询视为 offline
        poll_ok = 0
        for pid, cfg in panel_config.items():
            ps = port_state.get(pid, {})
            expected_ports = cfg.get('port_count', 24)
            polled_recently = sum(
                1 for p in ps.values()
                if p.get('last_polled_at') and (now_ms - p.get('last_polled_at', 0)) < threshold_ms
            )
            if polled_recently >= expected_ports:
                poll_ok += 1
        panel_online = poll_ok
        panel_offline = max(0, len(panel_config) - panel_online)

        # 检查串口状态
        serial_st = serial_client.get_status()
        rs485_status = 'normal' if (isinstance(serial_st, dict) and serial_st.get('connected', False)) else 'error'

        # 网络状态: 检查实际接口 UP 状态
        # 规则: 有线 (eth*/wlan*) UP → online; 仅 wifi 信号弱 (无 link/低质量) → weak; 否则 offline
        network_status = 'offline'
        try:
            interfaces = network_manager.get_network_status().get('interfaces', {})
            real_ifs = {i: s for i, s in interfaces.items()
                        if s.get('status') == 'UP'
                        and i not in ('lo', 'docker0')
                        and not i.startswith(('br-', 'veth'))}
            if real_ifs:
                # 优先有线连接
                if any(i.startswith(('eth', 'en')) for i in real_ifs):
                    network_status = 'online'
                else:
                    # 仅无线: 检查信号强度 (Linux: /proc/net/wireless)
                    try:
                        import re
                        with open('/proc/net/wireless') as f:
                            lines = f.readlines()
                        quality = None
                        for line in lines[2:]:  # 跳过表头
                            m = re.match(r'\s*(\S+):.*\s(\d+)\.\s+(\d+)\.\s+(\d+)', line)
                            if m:
                                # link quality (字段 2, 0-70); signal level (字段 3, dBm, 越低越差)
                                link = int(m.group(2))
                                sig = int(m.group(3))
                                # 估算: link < 30 或 sig < -75 dBm 视为弱
                                if quality is None or link < quality:
                                    quality = link
                        network_status = 'weak' if (quality is not None and quality < 30) else 'online'
                    except Exception:
                        network_status = 'online'
        except Exception:
            network_status = 'offline'

        # 屏幕连接状态：从 Nextion 屏幕实例读取
        screen_connected = screen_display.get_status().get('connected', False)

        # CPU/内存使用率 (Linux 才有意义)
        cpu_usage = _get_cpu_usage()
        memory_usage = _get_memory_usage()
        dtu_temperature = None
        try:
            # 主板温度: 优先 psutil.sensors_temperatures
            try:
                import psutil
                temps = psutil.sensors_temperatures(fahrenheit=False) or {}
                for chip_name, entries in temps.items():
                    for entry in entries:
                        if entry.current and entry.current > 0:
                            dtu_temperature = round(entry.current, 1)
                            break
                    if dtu_temperature is not None:
                        break
            except Exception:
                pass
            # 回退: 直接读 /sys/class/thermal/thermal_zone*/temp
            if dtu_temperature is None:
                import glob as _glob
                for tz in sorted(_glob.glob('/sys/class/thermal/thermal_zone*/temp')):
                    try:
                        with open(tz) as f:
                            v = int(f.read().strip())
                            if v > 0:
                                dtu_temperature = round(v / 1000.0, 1)
                                break
                    except Exception:
                        continue
        except Exception:
            pass

        # 优先使用外部上报的 dtu_temperature (来自 MQTT/RS485 传感器)
        dtu_temperature = env_sensor_data.get('dtu_temperature') or dtu_temperature

        payload = {
            'msg_id': f"hbt_{int(time.time() * 1000)}_{uuid.uuid4().hex[:6]}",
            'timestamp': int(time.time() * 1000),
            'dtu_id': dtu_config['dtu_id'],
            'type': 'STATUS',
            'payload': {
                'cpu_usage': cpu_usage,
                'memory_usage': memory_usage,
                'temperature': dtu_temperature,
                'network_status': network_status,
                'panel_online': panel_online,
                'panel_offline': panel_offline,
                'screen_connected': screen_connected,
                'mqtt_connected': _mqtt_connected(),
                'rs485_status': rs485_status
            }
        }

        topic = build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'status')
        success, _ = mqtt_client.publish(topic, json.dumps(payload), qos=1)
        return success
    except Exception as e:
        logger.error(f"发送DTU状态消息失败: {str(e)}")
        return False


def dtu_publish_event(panel_id, port_id, event_type, jumper_uid, previous_jumper_uid=None):
    """发送端口事件消息。

    入参 jumper_uid / previous_jumper_uid 为内部 12 位硬件卡号；
    MQTT 上行拼成 16 位（前 4 位 DTU 号 + 后 12 位卡号）。
    """
    if not _mqtt_connected() or not dtu_config.get('enabled'):
        return False

    try:
        mqtt_jumper = _to_mqtt_jumper_uid(jumper_uid)
        mqtt_prev = _to_mqtt_jumper_uid(previous_jumper_uid)
        payload = {
            'msg_id': f"evt_{int(time.time() * 1000)}",
            'timestamp': int(time.time() * 1000),
            'dtu_id': dtu_config['dtu_id'],
            'type': 'EVENT',
            'payload': {
                'panel_id': panel_id,
                'port_id': port_id,
                'event_type': event_type,
                'event_id': f"evt_{uuid.uuid4().hex[:8]}",
                'jumper_uid': mqtt_jumper,
                'previous_jumper_uid': mqtt_prev
            }
        }

        topic = build_dtu_topic(dtu_config['customer_id'], 'patchpanel', dtu_config['dtu_id'], panel_id, 'event')
        success, _ = mqtt_client.publish(topic, json.dumps(payload), qos=1)

        if success:
            logger.info(f"端口事件已发送: {panel_id}:{port_id} - {event_type}")
            # 记录到事件历史（保留内部 12 位，供本地前端/调试）
            port_event_history.append({
                'timestamp': int(time.time() * 1000),
                'panel_id': panel_id,
                'port_id': port_id,
                'event_type': event_type,
                'jumper_uid': jumper_uid,
                'previous_jumper_uid': previous_jumper_uid
            })
            # 限制历史记录数量
            if len(port_event_history) > 1000:
                port_event_history[:] = port_event_history[-1000:]

        # 事件驱动: 立即上报一次 status (符合 7.4 "状态变化时立即上报")
        try:
            dtu_publish_status(force=True)
        except Exception:
            pass
        return success
    except Exception as e:
        logger.error(f"发送端口事件失败: {str(e)}")
        return False


def dtu_publish_alarm(panel_id, port_id, alarm_type, expected_jumper_uid, actual_jumper_uid, severity='WARNING'):
    """发送非法告警消息。

    入参 expected_jumper_uid / actual_jumper_uid 为内部 12 位硬件卡号；
    MQTT 上行拼成 16 位（前 4 位 DTU 号 + 后 12 位卡号）。
    """
    if not _mqtt_connected() or not dtu_config.get('enabled'):
        return False

    try:
        mqtt_exp = _to_mqtt_jumper_uid(expected_jumper_uid)
        mqtt_act = _to_mqtt_jumper_uid(actual_jumper_uid)
        description = f"端口{port_id}期望跳线{mqtt_exp or '无'}，实际{'未读到' if not actual_jumper_uid else mqtt_act}"

        payload = {
            'msg_id': f"alm_{int(time.time() * 1000)}",
            'timestamp': int(time.time() * 1000),
            'dtu_id': dtu_config['dtu_id'],
            'type': 'ALARM',
            'payload': {
                'panel_id': panel_id,
                'port_id': port_id,
                'alarm_type': alarm_type,
                'severity': severity,
                'expected_jumper_uid': mqtt_exp,
                'actual_jumper_uid': mqtt_act,
                'description': description
            }
        }

        topic = build_dtu_topic(dtu_config['customer_id'], 'patchpanel', dtu_config['dtu_id'], panel_id, 'alarm')
        success, _ = mqtt_client.publish(topic, json.dumps(payload), qos=1)

        if success:
            logger.warning(f"非法告警已发送: {panel_id}:{port_id} - {alarm_type}")
            # 记录到事件历史（保留内部 12 位，供本地前端/调试）
            port_event_history.append({
                'timestamp': int(time.time() * 1000),
                'panel_id': panel_id,
                'port_id': port_id,
                'event_type': 'ALARM',
                'alarm_type': alarm_type,
                'expected_jumper_uid': expected_jumper_uid,
                'actual_jumper_uid': actual_jumper_uid
            })
            # 限制历史记录数量
            if len(port_event_history) > 1000:
                port_event_history[:] = port_event_history[-1000:]

        # 事件驱动: 告警后立即上报一次 status
        try:
            dtu_publish_status(force=True)
        except Exception:
            pass
        return success
    except Exception as e:
        logger.error(f"发送非法告警失败: {str(e)}")
        return False


def dtu_publish_panel_status(panel_id, address, ports_data, online=True):
    """发送配线架状态消息 (7.7)

    online=False 时表示面板已离线，ports 全部置为 UNKNOWN。
    """
    if not _mqtt_connected() or not dtu_config.get('enabled'):
        return False
    try:
        if not online:
            ports_data = [{'port_id': p, 'status': 'UNKNOWN', 'jumper_uid': None} for p in range(1, 25)]
        # MQTT 上行 jumper_uid 拼成 16 位（前 4 位 DTU 号 + 后 12 位卡号）
        mqtt_ports = [
            {**p, 'jumper_uid': _to_mqtt_jumper_uid(p.get('jumper_uid'))}
            for p in ports_data
        ]
        topic = build_dtu_topic(dtu_config['customer_id'], 'patchpanel', dtu_config['dtu_id'], panel_id, 'status')
        payload = {
            'msg_id': f"pst_{int(time.time() * 1000)}",
            'timestamp': int(time.time() * 1000),
            'dtu_id': dtu_config['dtu_id'],
            'type': 'STATUS',
            'payload': {
                'panel_id': panel_id,
                'position': panel_config.get(panel_id, {}).get('position', 0),
                'address': address,
                'panel_uid': panel_config.get(panel_id, {}).get('panel_uid'),
                'online': online,
                'last_poll_time': int(time.time() * 1000),
                'ports': mqtt_ports
            }
        }
        mqtt_client.publish(topic, json.dumps(payload), qos=0)
        return True
    except Exception as e:
        logger.error(f"发送面板状态失败: {str(e)}")
        return False


def dtu_publish_jumper_status():
    """发送跳线状态汇总 (7.8) - STATUS envelope with panels[] array"""
    if not _mqtt_connected() or not dtu_config.get('enabled'):
        return False
    try:
        panels_arr = []
        for panel_id, cfg in panel_config.items():
            ports_arr = []
            ps = port_state.get(panel_id, {})
            for port_id in range(1, 25):
                p = ps.get(port_id, {})
                last_uid = p.get('last_uid')
                expected_uid = p.get('expected_uid')
                last_polled = p.get('last_polled_at')
                if not last_polled:
                    status = 'UNKNOWN'
                elif last_uid is None:
                    status = 'DISCONNECTED'
                    if expected_uid:
                        status = 'ILLEGAL'
                elif expected_uid and last_uid != expected_uid:
                    status = 'ILLEGAL'
                else:
                    status = 'CONNECTED'
                ports_arr.append({
                    'port_id': port_id,
                    'status': status,
                    # MQTT 上行拼成 16 位（前 4 位 DTU 号 + 后 12 位卡号）
                    'jumper_uid': _to_mqtt_jumper_uid(last_uid)
                })
            panels_arr.append({
                'panel_id': panel_id,
                'position': cfg.get('position', 0),
                'ports': ports_arr
            })

        topic = build_dtu_topic(dtu_config['customer_id'], 'jumper', dtu_config['dtu_id'], 'status')
        payload = {
            'msg_id': f"jmp_{int(time.time() * 1000)}",
            'timestamp': int(time.time() * 1000),
            'dtu_id': dtu_config['dtu_id'],
            'type': 'STATUS',
            'payload': {'panels': panels_arr}
        }
        mqtt_client.publish(topic, json.dumps(payload), qos=0)
        return True
    except Exception as e:
        logger.error(f"发送跳线状态汇总失败: {str(e)}")
        return False


_env_sensor_data = {
    'temperature': None,
    'humidity': None,
    'sensor_update_time': None
}


def update_env_sensor_data(temperature, humidity, dtu_temperature=None, sensor_update_time=None):
    """更新环境传感器数据 - 委托给完整实现（带历史和告警）"""
    update_env_sensor_data_full(temperature, humidity, dtu_temperature, sensor_update_time)


def dtu_publish_env_sensor():
    """发送环境传感器数据 (7.9) - STATUS envelope"""
    if not _mqtt_connected() or not dtu_config.get('enabled'):
        return False
    try:
        topic = build_dtu_topic(dtu_config['customer_id'], 'env', dtu_config['dtu_id'], 'sensor')
        payload = {
            'msg_id': f"sen_{int(time.time() * 1000)}",
            'timestamp': int(time.time() * 1000),
            'dtu_id': dtu_config['dtu_id'],
            'type': 'STATUS',
            'payload': {
                'temperature': _env_sensor_data.get('temperature'),
                'humidity': _env_sensor_data.get('humidity'),
                'sensor_update_time': _env_sensor_data.get('sensor_update_time')
            }
        }
        mqtt_client.publish(topic, json.dumps(payload), qos=0)
        return True
    except Exception as e:
        logger.error(f"发送环境传感器数据失败: {str(e)}")
        return False


def _resolve_panel_id(target):
    """将 target 解析为 panel_config 中实际的 panel_id 键。

    兼容三种输入：
      - 完整 panel_id（如 'PANEL_dtu_001_2'）：原样返回（若存在）
      - 数字地址/序号（如 2 或 '2'）：尝试匹配 panel_config 中以该数字结尾的键
      - 'all' / None：原样返回（由调用方处理）
    """
    if target is None or target == 'all':
        return target
    if target in panel_config:
        return target
    # 数字型：尝试匹配 PANEL_*_{n} 或地址为 n 的面板
    try:
        num = int(target)
    except (TypeError, ValueError):
        return target
    # 1) 键以 _{num} 结尾
    for pid in panel_config:
        if pid.endswith(f'_{num}'):
            return pid
    # 2) 面板地址等于 num
    for pid, cfg in panel_config.items():
        if cfg.get('address') == num:
            return pid
    return target


def dtu_handle_control(topic, payload):
    """处理下行控制指令"""
    try:
        if not dtu_config.get('enabled'):
            return

        command = payload.get('payload', {}).get('command')
        target = payload.get('payload', {}).get('target')
        params = payload.get('payload', {}).get('params', {})

        logger.info(f"收到控制指令: command={command}, target={target}")

        response_payload = {
            'msg_id': f"rsp_{int(time.time() * 1000)}_{uuid.uuid4().hex[:6]}",
            'timestamp': int(time.time() * 1000),
            'dtu_id': dtu_config['dtu_id'],
            'type': 'RESPONSE',
            'payload': {
                'original_msg_id': payload.get('msg_id'),
                'command': command,
                'success': True,
                'result': {},
                'error_code': 0,
                'error_message': None
            }
        }
        topic_response_dtu = build_dtu_topic(
            dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'response')

        # 处理各命令
        if command == 'SET_PORT_LED':
            # 设置端口LED
            port_id = params.get('port_id')
            led_mode = params.get('led_mode', 'OFF')

            # 参数校验
            if port_id is None or not (1 <= int(port_id) <= 24):
                response_payload['payload']['success'] = False
                response_payload['payload']['error_code'] = 1003
                response_payload['payload']['error_message'] = f"端口号非法: {port_id}"
                mqtt_client.publish(topic_response_dtu, json.dumps(response_payload), qos=1)
                return

            if led_mode not in ('OFF', 'BLINK_RED', 'BLINK_GREEN', 'BLINK_BLUE'):
                response_payload['payload']['success'] = False
                response_payload['payload']['error_code'] = 1004
                response_payload['payload']['error_message'] = f"LED模式非法: {led_mode}"
                mqtt_client.publish(topic_response_dtu, json.dumps(response_payload), qos=1)
                return

            # LED模式映射
            led_mode_map = {'OFF': 0, 'BLINK_RED': 1, 'BLINK_GREEN': 2, 'BLINK_BLUE': 3}
            color = led_mode_map.get(led_mode, 0)

            # 查找设备地址
            device_address = 1  # 默认
            for panel_id, cfg in panel_config.items():
                if panel_id == target:
                    device_address = cfg.get('address', 1)
                    break

            result = modbus_client.set_rgb_led(device_address, port_id, color)
            response_payload['payload']['success'] = 'error' not in result
            response_payload['payload']['result'] = result
            if 'error' in result:
                response_payload['payload']['error_code'] = 1005
                response_payload['payload']['error_message'] = result['error']
            else:
                if device_address not in led_states:
                    led_states[device_address] = {}
                led_states[device_address][int(port_id)] = color
                _refresh_current_screen_panel()

        elif command == 'QUERY_DTU_STATUS':
            # 查询DTU状态
            dtu_publish_status(force=True)

        elif command == 'SYNC_PORT_MAPPING':
            # 同步单端口期望映射
            port_id = params.get('port_id')
            jumper_uid = params.get('jumper_uid')
            # 前端把 panel_id 放在 params 里（target='port' 占位），优先取 params.panel_id
            panel_target = params.get('panel_id')
            if panel_target is None:
                panel_target = target
            # 兼容数字 panel_id：前端可能传 2/3 或 'PANEL_dtu_001_2'
            panel_target = _resolve_panel_id(panel_target)

            if port_id is None or panel_target is None or panel_target not in panel_config:
                response_payload['payload']['success'] = False
                response_payload['payload']['error_code'] = 1006 if port_id is None else 1002
                response_payload['payload']['error_message'] = "参数缺失" if port_id is None else f"目标面板不存在: {panel_target}"
                mqtt_client.publish(topic_response_dtu, json.dumps(response_payload), qos=1)
                return

            try:
                # MQTT 16 位 -> 内部 12 位硬件卡号（剥前 4 位 DTU 号）
                expected_uid = _from_mqtt_jumper_uid(jumper_uid)
            except ValueError as e:
                response_payload['payload']['success'] = False
                response_payload['payload']['error_code'] = 1006
                response_payload['payload']['error_message'] = str(e)
                mqtt_client.publish(topic_response_dtu, json.dumps(response_payload), qos=1)
                return

            if panel_target not in port_state:
                port_state[panel_target] = {}
            if port_id not in port_state[panel_target]:
                port_state[panel_target][port_id] = {'last_uid': None, 'expected_uid': None, 'alarm_count': 0}

            port_state[panel_target][port_id]['expected_uid'] = expected_uid
            # 持久化期望映射（内部 12 位），保证离线恢复/重启后仍能判定非法连接
            dtu_config.setdefault('port_mappings', {}).setdefault(panel_target, {})[str(port_id)] = expected_uid
            save_dtu_config()

            # V4: 下发卡号到配线架硬件（24路同时发送；保留其他端口真实硬件值，避免误擦）
            device_address = panel_config[panel_target].get('address', 1)
            # 策略同 HTTP 单端口模式：硬件读基底 → dtu_config 覆盖 → 目标端口覆盖
            card_mappings = {i: None for i in range(1, 25)}
            try:
                hw_read = modbus_client.read_antenna_card(device_address, timeout=2.0)
                if 'error' not in hw_read:
                    for card in hw_read.get('cards', []):
                        ant = card.get('antenna')
                        cs = card.get('card_str') or card.get('uid')
                        if ant and cs and str(cs).lower() != 'ffffffffffff':
                            cs_clean = str(cs).strip().upper().replace(':', '').replace(' ', '')
                            if len(cs_clean) == 12 and all(c in _JUMPER_HEX for c in cs_clean):
                                card_mappings[int(ant)] = cs_clean
            except Exception as e:
                logger.warning(f"SYNC_PORT_MAPPING 读取硬件基底失败: {e}")
            # dtu_config 期望值覆盖（平台下发过的映射是权威）
            dtu_base = _build_card_mappings_for_panel(panel_target)
            for ant, v in dtu_base.items():
                if v is not None:
                    card_mappings[ant] = v
            # 目标端口覆盖（本次要设置/清除的值）
            try:
                card_mappings[int(port_id)] = expected_uid
            except (ValueError, TypeError):
                response_payload['payload']['success'] = False
                response_payload['payload']['error_code'] = 1006
                response_payload['payload']['error_message'] = f"port_id 非法: {port_id}"
                mqtt_client.publish(topic_response_dtu, json.dumps(response_payload), qos=1)
                return
            try:
                hw_result = modbus_client.set_card_mapping(device_address, card_mappings, timeout=2.0)
                if 'error' in hw_result:
                    response_payload['payload']['success'] = False
                    response_payload['payload']['error_code'] = 1008
                    response_payload['payload']['error_message'] = f"卡号下发硬件失败: {hw_result['error']}"
                    mqtt_client.publish(topic_response_dtu, json.dumps(response_payload), qos=1)
                    return
                response_payload['payload']['result'] = {'hardware': hw_result}
                logger.info(f"SYNC_PORT_MAPPING 面板{panel_target}端口{port_id} 卡号已下发硬件: {expected_uid}")
            except Exception as e:
                response_payload['payload']['success'] = False
                response_payload['payload']['error_code'] = 1008
                response_payload['payload']['error_message'] = f"卡号下发异常: {e}"
                mqtt_client.publish(topic_response_dtu, json.dumps(response_payload), qos=1)
                return

        elif command == 'SYNC_ALL_MAPPING':
            # 批量同步期望映射
            mappings = params.get('mappings', [])
            if not isinstance(mappings, list):
                response_payload['payload']['success'] = False
                response_payload['payload']['error_code'] = 1006
                response_payload['payload']['error_message'] = "mappings 字段格式错误"
                mqtt_client.publish(topic_response_dtu, json.dumps(response_payload), qos=1)
                return
            try:
                for mapping in mappings:
                    panel_id = _resolve_panel_id(mapping.get('panel_id'))
                    port_id = mapping.get('port_id')
                    jumper_uid = mapping.get('jumper_uid')
                    # MQTT 16 位 -> 内部 12 位硬件卡号（剥前 4 位 DTU 号），非法抛 ValueError
                    expected_uid = _from_mqtt_jumper_uid(jumper_uid)

                    if panel_id not in panel_config:
                        raise ValueError(f"目标面板不存在: {mapping.get('panel_id')}")
                    if panel_id not in port_state:
                        port_state[panel_id] = {}
                    if port_id not in port_state[panel_id]:
                        port_state[panel_id][port_id] = {'last_uid': None, 'expected_uid': None, 'alarm_count': 0}
                    port_state[panel_id][port_id]['expected_uid'] = expected_uid
                    # 持久化期望映射（内部 12 位）
                    dtu_config.setdefault('port_mappings', {}).setdefault(panel_id, {})[str(port_id)] = expected_uid
                save_dtu_config()
            except Exception as e:
                response_payload['payload']['success'] = False
                response_payload['payload']['error_code'] = 1007
                response_payload['payload']['error_message'] = f"同步映射失败: {e}"
                mqtt_client.publish(topic_response_dtu, json.dumps(response_payload), qos=1)
                return

            # V4: 对涉及的面板逐个下发卡号到硬件
            affected_panels = set()
            for mapping in mappings:
                pid = _resolve_panel_id(mapping.get('panel_id'))
                if pid:
                    affected_panels.add(pid)
            hw_results = {}
            hw_errors = {}
            for pid in affected_panels:
                device_address = panel_config[pid].get('address', 1)
                card_mappings = _build_card_mappings_for_panel(pid)
                try:
                    hw_result = modbus_client.set_card_mapping(device_address, card_mappings, timeout=2.0)
                    if 'error' in hw_result:
                        hw_errors[pid] = hw_result['error']
                    else:
                        hw_results[pid] = 'ok'
                        logger.info(f"SYNC_ALL_MAPPING 面板{pid} 卡号已下发硬件")
                except Exception as e:
                    hw_errors[pid] = str(e)
            if hw_errors:
                response_payload['payload']['success'] = False
                response_payload['payload']['error_code'] = 1008
                response_payload['payload']['error_message'] = f"部分面板卡号下发失败: {hw_errors}"
            response_payload['payload']['result'] = {'hardware': {'success': hw_results, 'errors': hw_errors}}

        elif command == 'REBOOT':
            # 重启DTU: 1s 延迟后执行 reboot
            import subprocess
            logger.warning(f"MQTT REBOOT 命令收到，1 秒后执行系统重启")
            threading.Thread(target=lambda: (
                time.sleep(1),
                subprocess.run(['reboot'], capture_output=True)
            ), daemon=True).start()
            response_payload['payload']['result'] = {'message': 'Reboot scheduled in 1s'}

        elif command == 'READ_PANEL_STATUS':
            # 读取面板状态
            # V4 寄存器: 0x0000=网络通断(保留), 0x0001=LED控制, 0x0002=批量卡号(144字节)
            device_address = 1
            for panel_id, cfg in panel_config.items():
                if panel_id == target:
                    device_address = cfg.get('address', 1)
                    break

            # V4: 只读 0x0000-0x0001（网络通断 + LED）；0x0002 起为批量卡号数据，不再作为状态寄存器
            status_result = modbus_client.read_holding_registers(device_address, 0x0000, 2)
            registers = status_result.get('registers', [])

            # V4: 天线在场状态由批量卡号读得出（24 元素 0/1 列表）
            bulk_result = modbus_client.read_all_antenna_cards(device_address)
            antenna_status = []
            if 'error' not in bulk_result:
                antenna_status = [1 if c.get('present') else 0 for c in bulk_result.get('cards', [])]

            panel_status = {
                'device_address': device_address,
                'run_status': registers[0] if len(registers) > 0 else None,
                'led_control': registers[1] if len(registers) > 1 else None,
                'antenna_status': antenna_status,
                'raw_registers': registers
            }

            response_payload['payload']['success'] = 'error' not in status_result
            response_payload['payload']['result'] = panel_status

        elif command == 'QUERY_JUMPER_STATUS':
            # 查询跳线器状态汇总 (7.8) - 触发 STATUS 上行至 jumper/{dtu_id}/status
            dtu_publish_jumper_status()
            return  # dtu_publish_jumper_status 已发送响应

        elif command == 'QUERY_ENV_SENSOR':
            # 查询环境传感器 (7.9) - 触发 STATUS 上行至 env/{dtu_id}/sensor
            dtu_publish_env_sensor()
            return  # dtu_publish_env_sensor 已发送响应

        elif command == 'OTA_UPGRADE':
            params = payload.get('payload', {}).get('params', {})
            target_version = params.get('firmware_version')
            force_upgrade = params.get('force_upgrade', False)
            current_version = dtu_config.get('firmware_version', 'v1.0.0')
            incoming_msg_id = payload.get('msg_id', '')
            if target_version == current_version and not force_upgrade:
                response_payload['payload']['success'] = False
                response_payload['payload']['error_code'] = 1021
                response_payload['payload']['error_message'] = f"已是目标版本: {target_version}"
                mqtt_client.publish(topic_response_dtu, json.dumps(response_payload), qos=1)
                return
            if params.get('firmware_url'):
                import threading
                threading.Thread(target=lambda: _run_ota({**params, '_incoming_msg_id': incoming_msg_id}), daemon=True).start()
            response_payload['payload']['success'] = True
            response_payload['payload']['result'] = {
                'firmware_version': target_version,
                'ota_status': 'DOWNLOADING',
                'restart_required': False
            }

        elif command == 'OTA_CANCEL':
            # 取消OTA升级
            # 向OTA控制寄存器写入取消命令 (0x0000=取消)
            device_address = 1
            for panel_id, cfg in panel_config.items():
                if panel_id == target:
                    device_address = cfg.get('address', 1)
                    break

            # OTA控制寄存器地址: 0x0300
            # 值: 0x0000=取消升级
            cancel_result = modbus_client.write_single_register(device_address, 0x0300, 0x0000)

            response_payload['payload']['success'] = 'error' not in cancel_result
            response_payload['payload']['result'] = {
                'message': 'OTA upgrade cancelled' if 'error' not in cancel_result else 'Failed to cancel OTA',
                'raw_result': cancel_result
            }

        else:
            # 未知命令
            response_payload['payload']['success'] = False
            response_payload['payload']['error_code'] = 1001
            response_payload['payload']['error_message'] = f"未知命令: {command}"
            mqtt_client.publish(topic_response_dtu, json.dumps(response_payload), qos=1)
            return

        # 发送响应（QUERY_DTU_STATUS 已由 dtu_publish_status 发送；QUERY_JUMPER_STATUS/QUERY_ENV_SENSOR 已在分支中发布）
        if command == 'QUERY_DTU_STATUS':
            pass
        else:
            cmd = command
            if cmd == 'READ_PANEL_STATUS':
                if target and target != 'all' and target in panel_config:
                    # 单个面板: 使用 panel_id 作为 topic segment
                    topic = build_dtu_topic(dtu_config['customer_id'], 'patchpanel',
                                            dtu_config['dtu_id'], target, 'status')
                    mqtt_client.publish(topic, json.dumps(response_payload), qos=0)
                else:
                    # target=all: 遍历所有面板发布到各自的 topic
                    for pid in panel_config.keys():
                        topic = build_dtu_topic(dtu_config['customer_id'], 'patchpanel',
                                                dtu_config['dtu_id'], pid, 'status')
                        mqtt_client.publish(topic, json.dumps(response_payload), qos=0)
            else:
                topic = build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'response')
                p = response_payload['payload']
                if not p.get('success', True) and p.get('error_code', 0) == 0:
                    p['error_code'] = 9999
                    p['error_message'] = p.get('error_message') or '未知错误'
                mqtt_client.publish(topic, json.dumps(response_payload), qos=1)

    except Exception as e:
        logger.error(f"处理控制指令失败: {str(e)}")


# 启动DTU心跳定时器
def start_dtu_heartbeat():
    """启动DTU心跳定时任务"""
    def heartbeat_task():
        env_tick = 0
        while True:
            socketio.sleep(dtu_config.get('heartbeat_interval', DTU_HEARTBEAT_INTERVAL))
            if _mqtt_connected() and dtu_config.get('enabled'):
                dtu_publish_status()
                # 每 2 个心跳周期 (120s) 主动推送一次环境传感器数据 (7.9)
                env_tick += 1
                if env_tick >= 2:
                    env_tick = 0
                    dtu_publish_env_sensor()

    socketio.start_background_task(target=heartbeat_task)


# 修改mqtt_data_handler以处理控制指令
def mqtt_data_handler_extended(data):
    """处理MQTT接收的数据（扩展版，含DTU协议）"""
    try:
        topic = data.get('topic', '')
        payload_str = data.get('payload', '')

        # 尝试解析JSON
        try:
            payload = json.loads(payload_str) if isinstance(payload_str, str) else payload_str
        except:
            payload = payload_str

        # 添加到缓冲区
        timestamp = time.strftime('%Y-%m-%d %H:%M:%S')
        mqtt_data_buffer.append({
            'timestamp': timestamp,
            'topic': topic,
            'payload': payload_str
        })
        if len(mqtt_data_buffer) > MAX_BUFFER_SIZE:
            mqtt_data_buffer.pop(0)

        # 通过WebSocket广播
        socketio.emit('mqtt_data', {
            'timestamp': timestamp,
            'topic': topic,
            'payload': payload_str
        }, namespace=SOCKETIO_NAMESPACE_DATA)

        # 检查是否是控制指令主题
        expected_control_topic = build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'control')
        if topic == expected_control_topic:
            dtu_handle_control(topic, payload)

        # 检查是否是状态主题，用于处理OTA状态上报
        expected_status_topic = build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'status')
        if topic == expected_status_topic and isinstance(payload, dict):
            if 'ota_status' in payload or 'firmware_version' in payload:
                handle_ota_status(dtu_config['dtu_id'], payload)

        # 检查是否是环境传感器数据主题 (兼容旧 sensor/.../data 路径，spec 7.9 为 env/.../sensor)
        sensor_topic = build_dtu_topic(dtu_config['customer_id'], 'sensor', dtu_config['dtu_id'], 'data')
        env_topic = build_dtu_topic(dtu_config['customer_id'], 'env', dtu_config['dtu_id'], 'sensor')
        if topic in (sensor_topic, env_topic) and isinstance(payload, dict):
            if 'temperature' in payload or 'humidity' in payload:
                update_env_sensor_data(
                    payload.get('temperature'),
                    payload.get('humidity'),
                    payload.get('dtu_temperature'),
                    payload.get('sensor_update_time')
                )

        # 检查是否是广播主题 - DTU发现 (7.14)
        discover_topic = build_dtu_topic('broadcast', 'dtu', 'discover')
        if topic == discover_topic:
            handle_broadcast_discover(payload)

        # 检查是否是广播主题 - 批量配置 (7.15)
        config_topic = build_dtu_topic('broadcast', 'dtu', 'config')
        if topic == config_topic:
            handle_broadcast_config(payload)

        # 转发到串口（如果启用）
        if forward_mqtt_to_serial and _serial_connected():
            success, msg = serial_client.send_data(payload_str)
            if not success:
                logger.warning(f"MQTT数据转发到串口失败: {msg}")
    except Exception as e:
        logger.error(f"处理MQTT数据时出错: {str(e)}")

# WebSocket事件处理
@socketio.on('connect', namespace=SOCKETIO_NAMESPACE_DATA)
def handle_data_connect():
    """处理数据命名空间的连接"""
    try:
        client_id = str(uuid.uuid4())
        connected_clients['data'].add(client_id)
        logger.info(f'客户端已连接到数据命名空间，当前连接数: {len(connected_clients["data"])}')
        
        # 发送当前的缓冲区数据，限制发送的历史记录数量
        max_history = 100  # 限制发送的历史记录数量以提高性能
        emit('serial_data_history', {'data': serial_data_buffer[-max_history:]})
        emit('mqtt_data_history', {'data': mqtt_data_buffer[-max_history:]})
        
        # 存储客户端ID以便断开连接时使用
        socketio.start_background_task(target=lambda: None)  # 确保上下文可用
    except Exception as e:
        logger.error(f"处理数据命名空间连接时出错: {str(e)}")

@socketio.on('connect', namespace=SOCKETIO_NAMESPACE_STATUS)
def handle_status_connect():
    """处理状态命名空间的连接"""
    try:
        client_id = str(uuid.uuid4())
        connected_clients['status'].add(client_id)
        logger.info(f'客户端已连接到状态命名空间，当前连接数: {len(connected_clients["status"])}')
        
        # 发送当前状态
        emit('serial_status', {'connected': serial_status})
        emit('mqtt_status', {'connected': mqtt_status})
        emit('forward_status', {
            'serial_to_mqtt': forward_serial_to_mqtt,
            'mqtt_to_serial': forward_mqtt_to_serial,
            'publish_topic': mqtt_publish_topic
        })
    except Exception as e:
        logger.error(f"处理状态命名空间连接时出错: {str(e)}")

@socketio.on('connect', namespace=SOCKETIO_NAMESPACE_CONTROL)
def handle_control_connect():
    """处理控制命名空间的连接"""
    try:
        client_id = str(uuid.uuid4())
        connected_clients['control'].add(client_id)
        logger.info(f'客户端已连接到控制命名空间，当前连接数: {len(connected_clients["control"])}')
    except Exception as e:
        logger.error(f"处理控制命名空间连接时出错: {str(e)}")

@socketio.on('disconnect', namespace=SOCKETIO_NAMESPACE_DATA)
def handle_data_disconnect():
    """处理数据命名空间的断开连接"""
    try:
        # 清理客户端连接记录
        # 在实际应用中，可能需要更复杂的逻辑来追踪具体哪个客户端断开了连接
        if len(connected_clients['data']) > 0:
            # 这里简化处理，实际应该维护session到client_id的映射
            connected_clients['data'].pop()  # 注意：这是一个简化的实现
        logger.info(f'客户端已断开数据命名空间的连接，当前连接数: {len(connected_clients["data"])}')
    except Exception as e:
        logger.error(f"处理数据命名空间断开连接时出错: {str(e)}")

@socketio.on('disconnect', namespace=SOCKETIO_NAMESPACE_STATUS)
def handle_status_disconnect():
    """处理状态命名空间的断开连接"""
    try:
        # 清理客户端连接记录
        if len(connected_clients['status']) > 0:
            connected_clients['status'].pop()
        logger.info(f'客户端已断开状态命名空间的连接，当前连接数: {len(connected_clients["status"])}')
    except Exception as e:
        logger.error(f"处理状态命名空间断开连接时出错: {str(e)}")

@socketio.on('disconnect', namespace=SOCKETIO_NAMESPACE_CONTROL)
def handle_control_disconnect():
    """处理控制命名空间的断开连接"""
    try:
        # 清理客户端连接记录
        if len(connected_clients['control']) > 0:
            connected_clients['control'].pop()
        logger.info(f'客户端已断开控制命名空间的连接，当前连接数: {len(connected_clients["control"])}')
    except Exception as e:
        logger.error(f"处理控制命名空间断开连接时出错: {str(e)}")

@socketio.on('serial_send', namespace=SOCKETIO_NAMESPACE_CONTROL)
def handle_serial_send(data):
    """通过WebSocket处理串口发送数据请求"""
    try:
        message = data.get('message', '')
        if not message:
            emit('serial_send_response', {
                'success': False,
                'message': '消息内容不能为空',
                'error_code': ERROR_CODES['CONFIG_ERROR']
            })
            return
        
        if not (isinstance(serial_client.get_status(), dict) and serial_client.get_status().get("connected", False)):
            emit('serial_send_response', {
                'success': False,
                'message': '串口未连接',
                'error_code': ERROR_CODES['SERIAL_CONNECTION_ERROR']
            })
            return
            
        success, msg = serial_client.send_data(message)
        emit('serial_send_response', {
            'success': success,
            'message': msg,
            'error_code': ERROR_CODES['SUCCESS'] if success else ERROR_CODES['SERIAL_SEND_ERROR']
        })
        
        if success:
            logger.info(f"通过WebSocket发送串口数据成功: {message[:50]}..." if len(message) > 50 else message)
    except Exception as e:
        error_msg = f"处理串口发送请求时出错: {str(e)}"
        logger.error(error_msg)
        emit('serial_send_response', {
            'success': False,
            'message': error_msg,
            'error_code': ERROR_CODES['UNKNOWN_ERROR']
        })

@socketio.on('mqtt_publish', namespace=SOCKETIO_NAMESPACE_CONTROL)
def handle_mqtt_publish(data):
    """通过WebSocket处理MQTT发布数据请求"""
    try:
        topic = data.get('topic', '')
        message = data.get('message', '')
        
        if not topic or not message:
            emit('mqtt_publish_response', {
                'success': False,
                'message': '主题或消息内容不能为空',
                'error_code': ERROR_CODES['CONFIG_ERROR']
            })
            return
        
        if not _mqtt_connected():
            emit('mqtt_publish_response', {
                'success': False,
                'message': 'MQTT未连接',
                'error_code': ERROR_CODES['MQTT_CONNECTION_ERROR']
            })
            return
            
        success, msg = mqtt_client.publish(topic, message)
        emit('mqtt_publish_response', {
            'success': success,
            'message': msg,
            'error_code': ERROR_CODES['SUCCESS'] if success else ERROR_CODES['MQTT_PUBLISH_ERROR']
        })
        
        if success:
            logger.info(f"通过WebSocket发布MQTT消息成功: 主题={topic}, 消息={message[:50]}..." if len(message) > 50 else message)
    except Exception as e:
        error_msg = f"处理MQTT发布请求时出错: {str(e)}"
        logger.error(error_msg)
        emit('mqtt_publish_response', {
            'success': False,
            'message': error_msg,
            'error_code': ERROR_CODES['UNKNOWN_ERROR']
        })

@socketio.on('update_forward_config', namespace=SOCKETIO_NAMESPACE_CONTROL)
def handle_update_forward_config(data):
    """通过WebSocket更新转发配置"""
    global forward_serial_to_mqtt, forward_mqtt_to_serial, mqtt_publish_topic
    
    try:
        # 更新转发标志
        if 'serial_to_mqtt' in data:
            forward_serial_to_mqtt = bool(data['serial_to_mqtt'])
        if 'mqtt_to_serial' in data:
            forward_mqtt_to_serial = bool(data['mqtt_to_serial'])
        if 'publish_topic' in data:
            new_topic = str(data['publish_topic'])
            if not new_topic.strip():
                raise ValueError("发布主题不能为空")
            mqtt_publish_topic = new_topic
        
        # 广播配置更新
        socketio.emit('forward_status', {
            'serial_to_mqtt': forward_serial_to_mqtt,
            'mqtt_to_serial': forward_mqtt_to_serial,
            'publish_topic': mqtt_publish_topic
        }, namespace=SOCKETIO_NAMESPACE_STATUS)
        
        emit('update_forward_config_response', {
            'success': True,
            'message': '转发配置已更新',
            'error_code': ERROR_CODES['SUCCESS']
        })
        
        logger.info(f"转发配置已更新 - 串口到MQTT: {forward_serial_to_mqtt}, MQTT到串口: {forward_mqtt_to_serial}, 发布主题: {mqtt_publish_topic}")
    except ValueError as e:
        error_msg = str(e)
        logger.warning(f"转发配置更新失败: {error_msg}")
        emit('update_forward_config_response', {
            'success': False,
            'message': error_msg,
            'error_code': ERROR_CODES['CONFIG_ERROR']
        })
    except Exception as e:
        error_msg = f'更新转发配置失败: {str(e)}'
        logger.error(error_msg)
        emit('update_forward_config_response', {
            'success': False,
            'message': error_msg,
            'error_code': ERROR_CODES['UNKNOWN_ERROR']
        })

@socketio.on('clear_data_buffer', namespace=SOCKETIO_NAMESPACE_CONTROL)
def handle_clear_data_buffer(data):
    """通过WebSocket清空数据缓冲区"""
    try:
        buffer_type = data.get('type', '')
        
        if buffer_type == 'serial':
            serial_data_buffer.clear()
            emit('clear_data_buffer_response', {
                'success': True,
                'message': '串口数据缓冲区已清空',
                'error_code': ERROR_CODES['SUCCESS']
            })
            logger.info("串口数据缓冲区已清空")
        elif buffer_type == 'mqtt':
            mqtt_data_buffer.clear()
            emit('clear_data_buffer_response', {
                'success': True,
                'message': 'MQTT数据缓冲区已清空',
                'error_code': ERROR_CODES['SUCCESS']
            })
            logger.info("MQTT数据缓冲区已清空")
        elif buffer_type == 'all':
            serial_data_buffer.clear()
            mqtt_data_buffer.clear()
            emit('clear_data_buffer_response', {
                'success': True,
                'message': '所有数据缓冲区已清空',
                'error_code': ERROR_CODES['SUCCESS']
            })
            logger.info("所有数据缓冲区已清空")
        else:
            emit('clear_data_buffer_response', {
                'success': False,
                'message': '无效的缓冲区类型',
                'error_code': ERROR_CODES['CONFIG_ERROR']
            })
            logger.warning(f"清空缓冲区失败: 无效的缓冲区类型 '{buffer_type}'")
    except Exception as e:
        error_msg = f'清空缓冲区失败: {str(e)}'
        logger.error(error_msg)
        emit('clear_data_buffer_response', {
            'success': False,
            'message': error_msg,
            'error_code': ERROR_CODES['UNKNOWN_ERROR']
        })

# 设置回调
serial_client.set_data_callback(serial_data_handler)
serial_client.set_send_callback(serial_send_handler)
serial_client.set_status_callback(serial_status_handler)
mqtt_client.set_data_callback(mqtt_data_handler_extended)
mqtt_client.set_status_callback(mqtt_status_handler)

# 设备配置文件路径
DEVICE_CONFIG_FILE = '/root/dzxj_dtu/devices.json'
confirm_loop_running = False


def save_device_config():
    """保存设备配置到文件（快照 + 原子写）"""
    try:
        filepath = DEVICE_CONFIG_FILE
        success = _save_config_file(filepath, address_config.get_stored_devices(), '设备配置')
        if success:
            logger.info(f"设备配置已保存到: {filepath}")
    except Exception as e:
        logger.error(f"保存设备配置失败: {str(e)}")


def load_device_config():
    """加载设备配置（文件损坏时回退最新快照）"""
    try:
        filepath = DEVICE_CONFIG_FILE
        if os.path.exists(filepath):
            try:
                devices = config_backup.read_json_file(filepath)
            except Exception as e:
                logger.error(f"读取设备配置失败: {e}，尝试回退快照")
                devices, snap = config_backup.latest_snapshot_content(filepath, BACKUP_DIR)
                if not isinstance(devices, dict):
                    return {}
                logger.warning(f"已从快照恢复设备配置: {snap}")
            if isinstance(devices, dict):
                address_config.stored_devices = devices
                logger.info(f"已加载 {len(devices)} 个设备配置")
                return devices
    except Exception as e:
        logger.error(f"加载设备配置失败: {str(e)}")
    return {}


def _merge_panel_config(new_config):
    """合并面板配置：叠加新发现的在线设备，并保留已标记为离线的面板

    离线设备保留在 panel_config 中（status='offline'），UI 可显示离线状态，
    轮询循环会跳过它们不再发查询；广播发现仍会定期尝试重新上线。
    """
    global panel_config
    merged = dict(new_config)
    for panel_id, cfg in panel_config.items():
        if cfg.get('status') == 'offline' and panel_id not in merged:
            merged[panel_id] = cfg
    panel_config = merged
    return merged


def sync_panel_config():
    """根据 address_config.stored_devices 同步 panel_config"""
    global panel_config
    try:
        devices = address_config.get_stored_devices()
        panel_id_map = dtu_config.get('panel_id_mapping', {}) or {}
        new_config = {}
        for uid_hex, addr in devices.items():
            custom_id = panel_id_map.get(uid_hex) or panel_id_map.get(addr)
            if custom_id:
                panel_id = str(custom_id)
            else:
                panel_id = f"PANEL_{dtu_config.get('dtu_id', 'DTU001')}_{addr}"
            new_config[panel_id] = {
                'address': addr,
                'position': addr,
                'panel_uid': uid_hex,
                'status': 'online'
            }
        _merge_panel_config(new_config)
        logger.info(f"已同步面板配置: {len(panel_config)} 个面板")
    except Exception as e:
        logger.error(f"同步面板配置失败: {str(e)}")


def sync_panel_config_from_results(results):
    """根据本次自动配置结果同步 panel_config，只把真实发现/分配到的设备加入轮询"""
    global panel_config
    try:
        panel_id_map = dtu_config.get('panel_id_mapping', {}) or {}
        new_config = {}
        for r in results:
            if r.get('status') != 'assigned':
                continue
            uid_hex = r.get('uid')
            addr = r.get('address')
            if not uid_hex or not addr:
                continue
            custom_id = panel_id_map.get(uid_hex) or panel_id_map.get(addr)
            if custom_id:
                panel_id = str(custom_id)
            else:
                panel_id = f"PANEL_{dtu_config.get('dtu_id', 'DTU001')}_{addr}"
            new_config[panel_id] = {
                'address': addr,
                'position': addr,
                'panel_uid': uid_hex,
                'status': 'online'
            }
        _merge_panel_config(new_config)
        logger.info(f"已同步面板配置(发现模式): {len(panel_config)} 个面板")
    except Exception as e:
        logger.error(f"同步面板配置失败: {str(e)}")


def confirm_loop():
    """后台确认线程：每10秒对所有已存储设备发送 confirm_address"""
    global confirm_loop_running
    confirm_loop_running = True
    logger.info("启动设备确认线程 (间隔10秒)")

    while confirm_loop_running:
        try:
            devices = address_config.get_stored_devices()
            if not devices:
                time.sleep(10)
                continue

            if not _serial_connected():
                time.sleep(10)
                continue

            _st = serial_client.get_status()
            if not (isinstance(_st, dict) and _st.get('connected', False)):
                time.sleep(10)
                continue

            for uid_hex, addr in devices.items():
                try:
                    uid_bytes = bytes.fromhex(uid_hex)
                    cmd = build_confirm_address(addr, uid_bytes)
                    success, msg = serial_client.send_raw(cmd)
                    if success:
                        logger.debug(f"确认设备: 地址={addr}, UID={uid_hex[:16]}...")
                    else:
                        logger.warning(f"确认失败 地址={addr}: {msg}")
                except Exception as e:
                    logger.error(f"确认异常 地址={addr}: {str(e)}")
                time.sleep(0.1)

        except Exception as e:
            logger.error(f"确认线程异常: {str(e)}")

        time.sleep(10)


# API路由
# 移除静态文件服务，前端由nginx提供服务

# 根路径路由
@app.route('/')
def index():
    return send_from_directory(STATIC_FOLDER, 'index.html')

# 404错误处理器 - 解决SPA路由刷新问题
@app.errorhandler(404)
def page_not_found(e):
    """处理所有404错误，对于非API路径返回index.html"""
    path = request.path
    # 检查是否是API请求
    if path.startswith('/api/'):
        # 对于API请求，返回404错误
        return jsonify({
            'success': False,
            'message': 'API endpoint not found'
        }), 404
    # 对于所有非API路径，返回index.html让前端路由处理
    return send_from_directory(STATIC_FOLDER, 'index.html'), 200

@app.route('/api/serial/ports', methods=['GET'])
def get_serial_ports():
    """获取可用串口列表"""
    ports = serial_client.list_ports()
    return jsonify({
        'success': True,
        'ports': ports
    })

@app.route('/api/serial/connect', methods=['POST'])
def serial_connect():
    """连接串口"""
    try:
        data = request.json
        port = data.get('port')
        baudrate = data.get('baudrate', 9600)
        bytesize = data.get('bytesize', 8)
        parity = data.get('parity', 'N')
        stopbits = data.get('stopbits', 1)
        timeout = data.get('timeout', 0.1)
        
        if not port:
            logger.warning("连接串口请求缺少串口名称")
            return jsonify({
                'success': False, 
                'message': '串口名称不能为空',
                'error_code': ERROR_CODES['CONFIG_ERROR']
            }), 400
        
        # 先断开之前的连接
        _status = serial_client.get_status()
        if isinstance(_status, dict) and _status.get('connected', False):
            _port = serial_client.current_config.port if serial_client.current_config else 'unknown'
            logger.info(f"断开现有串口连接: {_port}")
            serial_client.disconnect()
        
        # 连接新的串口
        logger.info(f"尝试连接串口: {port}, 波特率: {baudrate}")
        success, message = serial_client.connect(port, baudrate=baudrate, timeout=timeout, bytesize=bytesize, parity=parity, stopbits=stopbits)
        
        status_code = 200 if success else 400
        error_code = ERROR_CODES['SUCCESS'] if success else ERROR_CODES['SERIAL_CONNECTION_ERROR']
        
        response = {
            'success': success, 
            'message': message,
            'error_code': error_code
        }

        if success:
            logger.info(f"串口连接成功: {port}")
            # 保存串口配置
            save_serial_config(port, baudrate, timeout, bytesize, parity, stopbits)
        else:
            logger.error(f"串口连接失败: {message}")

        return jsonify(response), status_code
    except Exception as e:
        error_msg = f'连接串口时出错: {str(e)}'
        logger.exception(error_msg)  # 使用exception记录完整堆栈
        return jsonify({
            'success': False, 
            'message': error_msg,
            'error_code': ERROR_CODES['UNKNOWN_ERROR']
        }), 500

@app.route('/api/serial/disconnect', methods=['POST'])
def serial_disconnect():
    """断开串口连接"""
    success, message = serial_client.disconnect()
    return jsonify({
        'success': success,
        'message': message
    })

@app.route('/api/serial/status', methods=['GET'])
def serial_get_status():
    """获取串口状态"""
    _st = serial_client.get_status()
    saved_config = {}
    try:
        with open(SERIAL_CONFIG_FILE, 'r') as f:
            saved_config = json.load(f)
    except (FileNotFoundError, json.JSONDecodeError):
        pass
    result = {'saved_config': saved_config}
    if isinstance(_st, dict):
        result['connected'] = _st.get('connected', False)
        if result['connected']:
            cfg = _st.get('config')
            result['port'] = cfg.port if cfg else None
        else:
            result['port'] = None
    else:
        result['connected'] = bool(_st)
        result['port'] = None
    return jsonify(result)

@app.route('/api/serial/send', methods=['POST'])
def serial_send():
    """发送数据到串口"""
    data = request.json
    message = data.get('message')
    
    if not message:
        return jsonify({
            'success': False,
            'message': '消息内容不能为空'
        })
    
    success, message = serial_client.send_data(message)
    return jsonify({
        'success': success,
        'message': message
    })

@app.route('/api/mqtt/connect', methods=['POST'])
def mqtt_connect():
    """连接MQTT服务器"""
    try:
        data = request.json
        host = data.get('broker') or data.get('host', 'localhost')
        port = data.get('port', 1883)
        client_id = data.get('client_id', f'serial_gateway_{int(time.time())}')
        username = data.get('username')
        password = data.get('password')
        keepalive = data.get('keepalive', 60)
        
        # 先断开之前的连接
        if _mqtt_connected():
            _old = mqtt_client.config
            _old_info = f"{_old.broker}:{_old.port}" if _old else "unknown"
            logger.info(f"断开现有MQTT连接: {_old_info}")
            mqtt_client.disconnect()
        
        # 连接新的MQTT服务器
        logger.info(f"尝试连接MQTT服务器: {host}:{port}, 客户端ID: {client_id}")
        will_topic = build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'status')
        will_payload = json.dumps({
            'dtu_id': dtu_config['dtu_id'], 'type': 'STATUS',
            'payload': {'online': False, 'reason': 'CONNECTION_LOST'}
        })
        success, message = mqtt_client.connect(
            broker=host, port=port, client_id=client_id,
            username=username or "", password=password or "",
            keepalive=keepalive,
            will_topic=will_topic, will_payload=will_payload, will_qos=1, will_retain=False
        )
        
        # 如果连接成功，订阅主题
        if success and 'topics' in data:
            mqtt_client.subscribe(data['topics'])
        
        status_code = 200 if success else 400
        error_code = ERROR_CODES['SUCCESS'] if success else ERROR_CODES['MQTT_CONNECTION_ERROR']
        
        response = {
            'success': success, 
            'message': message,
            'error_code': error_code
        }
        
        if success:
            logger.info(f"MQTT服务器连接成功: {host}:{port}")
            save_mqtt_config(
                broker=host, port=port, client_id=client_id,
                username=username or "", password=password or "",
                keepalive=keepalive,
                topics=data.get('topics', [])
            )
        else:
            logger.error(f"MQTT服务器连接失败: {message}")
        
        return jsonify(response), status_code
    except Exception as e:
        error_msg = f'连接MQTT服务器时出错: {str(e)}'
        logger.exception(error_msg)
        return jsonify({
            'success': False, 
            'message': error_msg,
            'error_code': ERROR_CODES['UNKNOWN_ERROR']
        }), 500

@app.route('/api/mqtt/disconnect', methods=['POST'])
def mqtt_disconnect():
    """断开MQTT连接"""
    success, message = mqtt_client.disconnect()
    return jsonify({
        'success': success,
        'message': message
    })

@app.route('/api/mqtt/status', methods=['GET'])
def mqtt_get_status():
    """获取MQTT状态"""
    _st = mqtt_client.get_status()
    return jsonify({
        'connected': _st.get('connected', False) if isinstance(_st, dict) else bool(_st)
    })

@app.route('/api/mqtt/publish', methods=['POST'])
def mqtt_publish():
    """发布MQTT消息"""
    data = request.json
    topic = data.get('topic')
    message = data.get('message')
    
    if not topic or not message:
        return jsonify({
            'success': False,
            'message': '主题和消息内容不能为空'
        })
    
    success, message = mqtt_client.publish(topic, message)
    return jsonify({
        'success': success,
        'message': message
    })

@app.route('/api/mqtt/subscribe', methods=['POST'])
def mqtt_subscribe():
    """订阅MQTT主题"""
    data = request.json
    topics = data.get('topics', [])

    if not topics:
        return jsonify({
            'success': False,
            'message': '请至少订阅一个主题'
        })

    success, message = mqtt_client.subscribe(topics)
    return jsonify({
        'success': success,
        'message': message
    })


@app.route('/api/mqtt/broadcast_discover', methods=['POST'])
def mqtt_broadcast_discover():
    """发送DTU发现广播 (7.14)

    服务器通过广播主题发送DISCOVER消息，
    触发所有在线DTU进行注册响应
    """
    data = request.json or {}
    customer_id = data.get('customer_id', dtu_config.get('customer_id', 'default'))

    discover_topic = build_dtu_topic('broadcast', 'dtu', 'discover')
    request_id = f"dsc_{int(time.time() * 1000)}"
    payload = {
        'msg_id': request_id,
        'timestamp': int(time.time() * 1000),
        'dtu_id': 'PLATFORM',
        'type': 'DISCOVER',
        'payload': {
            'request_id': request_id,
            'customer_id': customer_id
        }
    }

    success, message = mqtt_client.publish(discover_topic, json.dumps(payload), qos=1)
    logger.info(f"发送DTU发现广播: topic={discover_topic}, payload={payload}")

    return jsonify({
        'success': success,
        'message': 'DTU发现广播已发送' if success else message,
        'topic': discover_topic
    })


@app.route('/api/mqtt/broadcast_config', methods=['POST'])
def mqtt_broadcast_config():
    """发送DTU批量配置广播 (7.15)

    服务器通过广播主题发送CONFIG消息，
    用于批量配置所有在线DTU
    """
    data = request.json or {}
    customer_id = data.get('customer_id', dtu_config.get('customer_id', 'default'))
    config_items = data.get('items', {})
    config_version = data.get('config_version', f"cfg_{int(time.time())}")
    force_apply = data.get('force_apply', False)

    config_topic = build_dtu_topic('broadcast', 'dtu', 'config')
    payload = {
        'msg_id': f"cfg_{int(time.time() * 1000)}",
        'timestamp': int(time.time() * 1000),
        'dtu_id': 'PLATFORM',
        'type': 'CONFIG',
        'payload': {
            'customer_id': customer_id,
            'config_version': config_version,
            'force_apply': force_apply,
            'items': config_items
        }
    }

    success, message = mqtt_client.publish(config_topic, json.dumps(payload), qos=1)
    logger.info(f"发送DTU批量配置广播: topic={config_topic}, payload={payload}")

    return jsonify({
        'success': success,
        'message': 'DTU批量配置广播已发送' if success else message,
        'topic': config_topic,
        'config': {
            'config_version': config_version,
            'items': config_items,
            'force_apply': force_apply
        }
    })


@app.route('/api/data/serial', methods=['GET'])
def get_serial_data():
    """获取串口数据"""
    return jsonify({
        'data': serial_data_buffer
    })

@app.route('/api/data/mqtt', methods=['GET'])
def get_mqtt_data():
    """获取MQTT数据"""
    return jsonify({
        'data': mqtt_data_buffer
    })

@app.route('/api/forward/config', methods=['POST'])
def set_forward_config():
    """设置转发配置"""
    global forward_serial_to_mqtt, forward_mqtt_to_serial, mqtt_publish_topic
    
    data = request.json
    forward_serial_to_mqtt = data.get('serial_to_mqtt', False)
    forward_mqtt_to_serial = data.get('mqtt_to_serial', False)
    if 'publish_topic' in data:
        mqtt_publish_topic = data['publish_topic']
    
    return jsonify({
        'success': True,
        'message': '转发配置已更新',
        'config': {
            'serial_to_mqtt': forward_serial_to_mqtt,
            'mqtt_to_serial': forward_mqtt_to_serial,
            'publish_topic': mqtt_publish_topic
        }
    })

@app.route('/api/forward/status', methods=['GET'])
def get_forward_status():
    """获取转发状态"""
    return jsonify({
        'serial_to_mqtt': forward_serial_to_mqtt,
        'mqtt_to_serial': forward_mqtt_to_serial,
        'publish_topic': mqtt_publish_topic
    })

# 健康检查端点
@app.route('/api/health', methods=['GET'])
def health_check():
    """健康检查端点"""
    try:
        # 获取客户端连接数量
        client_counts = {
            'data': len(connected_clients['data']),
            'status': len(connected_clients['status']),
            'control': len(connected_clients['control'])
        }
        
        # 获取缓冲区大小
        buffer_sizes = {
            'serial': len(serial_data_buffer),
            'mqtt': len(mqtt_data_buffer)
        }
        
        # 执行系统负载检查
        # 注意：这只是一个简化的负载检查，实际应用中可能需要更复杂的监控
        is_healthy = True
        load_warnings = []
        
        # 检查缓冲区是否过大
        if buffer_sizes['serial'] > MAX_BUFFER_SIZE * 0.8:
            is_healthy = False
            load_warnings.append(f"串口缓冲区接近最大容量: {buffer_sizes['serial']}/{MAX_BUFFER_SIZE}")
            
        if buffer_sizes['mqtt'] > MAX_BUFFER_SIZE * 0.8:
            is_healthy = False
            load_warnings.append(f"MQTT缓冲区接近最大容量: {buffer_sizes['mqtt']}/{MAX_BUFFER_SIZE}")
        
        # 检查WebSocket连接数是否过多
        total_clients = sum(client_counts.values())
        if total_clients > 100:  # 设置合理的阈值
            is_healthy = False
            load_warnings.append(f"WebSocket连接数过多: {total_clients}")
        
        # 尝试获取网络状态信息（使用try-except包装，防止网络模块出错导致健康检查失败）
        network_info = None
        try:
            network_info = network_manager.get_network_status()
        except Exception as e:
            logger.warning(f"获取网络状态时出错: {str(e)}")
            # 不影响整体健康检查，只添加警告
            load_warnings.append(f"网络状态获取失败: {str(e)}")
        
        response = {
            'status': 'healthy' if is_healthy else 'warning',
            'timestamp': time.strftime('%Y-%m-%d %H:%M:%S'),
            'services': {
                'serial': serial_status,
                'mqtt': mqtt_status,
                'websocket': True
            },
            'client_counts': client_counts,
            'buffer_sizes': buffer_sizes,
            'warnings': load_warnings
        }
        
        # 仅当获取到网络信息时添加
        if network_info:
            response['network'] = network_info
        
        return jsonify(response), 200
    except Exception as e:
        # 捕获所有异常，确保健康检查不会返回500错误
        logger.error(f"健康检查端点出错: {str(e)}")
        # 返回一个基础的健康状态，至少显示服务在运行
        return jsonify({
            'status': 'error',
            'timestamp': time.strftime('%Y-%m-%d %H:%M:%S'),
            'error': str(e),
            'services': {
                'api': True,  # API服务本身是运行的
                'serial': None,
                'mqtt': None,
                'websocket': None
            }
        }), 200  # 仍然返回200，避免健康检查导致的连锁反应


@app.route('/api/screen/status', methods=['GET'])
def get_screen_status():
    """获取 Nextion 屏幕状态。"""
    with screen_lock:
        panels = get_sorted_panels()
        current_index = screen_current_panel_index
        current_panel_id = None
        if panels and 0 <= current_index < len(panels):
            current_panel_id = panels[current_index][0]
        panel_count = len(panels)
    status = screen_display.get_status()
    return jsonify({
        'success': True,
        'data': {
            'connected': status.get('connected', False),
            'port': status.get('port'),
            'baudrate': status.get('baudrate'),
            'current_panel_index': current_index,
            'current_panel_id': current_panel_id,
            'panel_count': panel_count
        }
    })


@app.route('/api/screen/refresh', methods=['POST'])
def refresh_screen():
    """手动刷新当前 panel 到屏幕。"""
    with screen_lock:
        panels = get_sorted_panels()
        if not panels:
            return jsonify({'success': False, 'message': '没有可用的 panel'}), 400
        if not (0 <= screen_current_panel_index < len(panels)):
            return jsonify({'success': False, 'message': '当前 panel 索引无效'}), 400
        panel_id = panels[screen_current_panel_index][0]
    success, message = refresh_screen_panel(panel_id)
    if success:
        return jsonify({'success': True, 'message': message})
    return jsonify({'success': False, 'message': message}), 400


@app.route('/api/screen/test_cmd', methods=['POST'])
def screen_test_cmd():
    """向 Nextion 屏幕发送原始命令（调试用）。"""
    try:
        data = request.json
        cmd = data.get('cmd')
        if not cmd:
            return jsonify({'success': False, 'message': '缺少 cmd 参数'}), 400
        status = screen_display.get_status()
        if not status.get('connected'):
            return jsonify({'success': False, 'message': '屏幕串口未连接'}), 400
        ok = screen_display.send_cmd(cmd, delay_ms=data.get('delay_ms', 50))
        logger.info(f"[Nextion TEST] cmd={cmd} ok={ok}")
        return jsonify({'success': ok, 'cmd': cmd, 'screen_connected': True})
    except Exception as e:
        logger.error(f"屏幕测试命令失败: {e}")
        return jsonify({'success': False, 'message': str(e)}), 500


# 网络配置相关API
@app.route('/api/network/config', methods=['GET'])
def get_network_config():
    """获取当前网络配置"""
    try:
        config = network_manager.get_network_config()
        return jsonify(config)
    except Exception as e:
        logger.error(f'获取网络配置失败: {str(e)}')
        return jsonify({'success': False, 'message': f'获取网络配置失败: {str(e)}'}), 500

@app.route('/api/network/config', methods=['POST'])
def update_network_config():
    """更新网络配置"""
    try:
        config_data = request.json
        result = network_manager.update_network_config(config_data)
        if result['success']:
            return jsonify(result)
        else:
            return jsonify(result), 400
    except Exception as e:
        logger.error(f'更新网络配置失败: {str(e)}')
        return jsonify({'success': False, 'message': f'更新网络配置失败: {str(e)}'}), 500

@app.route('/api/network/status', methods=['GET'])
def get_network_status():
    """获取网络状态信息"""
    try:
        status = network_manager.get_network_status()
        return jsonify(status)
    except Exception as e:
        logger.error(f'获取网络状态失败: {str(e)}')
        return jsonify({'success': False, 'message': f'获取网络状态失败: {str(e)}'}), 500

@app.route('/api/network/restart', methods=['POST'])
def restart_network_service():
    """重启网络服务以应用新配置"""
    try:
        result = network_manager.restart_network_service()
        if result['success']:
            return jsonify(result)
        else:
            return jsonify(result), 500
    except Exception as e:
        logger.error(f'重启网络服务失败: {str(e)}')
        return jsonify({'success': False, 'message': f'重启网络服务失败: {str(e)}'}), 500

# Modbus RTU API
@app.route('/api/modbus/antenna_addresses', methods=['GET'])
def get_antenna_addresses():
    """获取天线地址映射表"""
    return jsonify({
        'success': True,
        'antennas': {str(k): f"0x{v:04x}" for k, v in ANTENNA_ADDRESSES.items()}
    })


@app.route('/api/modbus/read_antenna', methods=['POST'])
def modbus_read_antenna():
    """读取指定天线的卡号

    请求参数:
    {
        "device_address": 1,      // 设备地址 (1-247)
        "antenna": 1,             // 天线编号 (1-24)
        "timeout": 1.0            // 可选，超时时间(秒)
    }
    """
    try:
        data = request.json
        device_address = data.get('device_address', 1)
        antenna = data.get('antenna', 1)
        timeout = data.get('timeout')

        if antenna < 1 or antenna > 24:
            return jsonify({
                'success': False,
                'message': f'无效的天线编号: {antenna}, 必须是1-24'
            }), 400

        if not (isinstance(serial_client.get_status(), dict) and serial_client.get_status().get("connected", False)):
            return jsonify({
                'success': False,
                'message': '串口未连接'
            }), 400

        result = modbus_client.read_antenna_card(
            device_address=device_address,
            antenna_num=antenna,
            timeout=timeout
        )

        if 'error' in result:
            return jsonify({
                'success': False,
                'message': result['error'],
                'raw_data': result.get('raw_data', '')
            }), 400

        return jsonify({
            'success': True,
            'data': result
        })

    except Exception as e:
        logger.error(f'读取天线数据失败: {str(e)}')
        return jsonify({
            'success': False,
            'message': str(e)
        }), 500


@app.route('/api/modbus/read_all_cards', methods=['POST'])
def modbus_read_all_cards():
    """V4: 一次批量读取全部 24 路天线卡号

    请求参数:
    {
        "device_address": 2,
        "timeout": 1.0
    }
    返回:
    {
        "success": true,
        "data": {
            "device_address": 2,
            "cards": [
                {"antenna": 1, "present": false, "card_str": "", "uid": ""},
                {"antenna": 2, "present": true, "card_str": "aabbccddeeff", "uid": "aa:bb:cc:dd:ee:ff"},
                ...
            ]
        }
    }
    """
    try:
        data = request.json or {}
        device_address = data.get('device_address', 1)
        timeout = data.get('timeout')

        if not (isinstance(serial_client.get_status(), dict) and serial_client.get_status().get("connected", False)):
            return jsonify({'success': False, 'message': '串口未连接'}), 400

        result = modbus_client.read_all_antenna_cards(device_address, timeout=timeout)

        if 'error' in result:
            return jsonify({
                'success': False,
                'message': result['error'],
                'raw_data': result.get('raw_data', '')
            }), 400

        return jsonify({'success': True, 'data': result})

    except Exception as e:
        logger.error(f'批量读卡失败: {str(e)}')
        return jsonify({'success': False, 'message': str(e)}), 500


@app.route('/api/modbus/set_card_mapping', methods=['POST'])
def modbus_set_card_mapping():
    """V4: 设置24路天线卡号到配线架硬件（0x10 写 0x0003，144字节）

    请求参数:
    {
        "device_address": 1,
        "card_mappings": {"1": "aabbccddeeff", "2": null, ...},  // 完整模式：24路映射
        // 或单端口模式:
        "port_id": 1,
        "card_uid": "aabbccddeeff",   // null/空表示清除该端口卡号
        "panel_id": "PANEL_dtu_001_2", // 单端口模式下用于读取其余端口期望卡号（可选）
        "timeout": 2.0
    }
    返回:
    {
        "success": true,
        "data": {"device_address": 1, "cards_written": {...}, "raw_data": "..."}
    }
    """
    try:
        data = request.json or {}
        device_address = data.get('device_address', 1)
        timeout = data.get('timeout')

        if not (isinstance(serial_client.get_status(), dict) and serial_client.get_status().get("connected", False)):
            return jsonify({'success': False, 'message': '串口未连接'}), 400

        card_mappings = data.get('card_mappings')
        if card_mappings is None:
            # 单端口模式：构建 24 路数据，避免擦掉其他端口
            # 策略: 先读硬件当前值做基底 → 再用 dtu_config 期望值覆盖 → 最后覆盖目标端口
            # 这样 dtu_config 没记录但硬件已有卡号的端口（例如修复前设置的）不会被误清为 0xFF
            port_id = data.get('port_id')
            card_uid = data.get('card_uid')
            # panel_id 解析：前端传的优先，否则用 device_address 反查 panel_config（LedDebug.vue 默认只传 address）
            panel_id_from_req = _resolve_panel_id(data.get('panel_id'))
            panel_id_from_addr = None
            for pid, cfg in panel_config.items():
                if cfg.get('address') == device_address:
                    panel_id_from_addr = pid
                    break
            panel_id = panel_id_from_req or panel_id_from_addr

            if port_id is None:
                return jsonify({'success': False, 'message': '缺少 port_id 或 card_mappings'}), 400

            # 第一步：读硬件当前 24 路值，作为默认基底（防止擦掉其他端口硬件里真实存在的卡号）
            card_mappings = {i: None for i in range(1, 25)}
            try:
                hw_read = modbus_client.read_antenna_card(device_address, timeout=2.0)
                if 'error' not in hw_read:
                    for card in hw_read.get('cards', []):
                        ant = card.get('antenna')
                        cs = card.get('card_str') or card.get('uid')
                        if ant and cs and str(cs).lower() != 'ffffffffffff':
                            cs_clean = str(cs).strip().upper().replace(':', '').replace(' ', '')
                            if len(cs_clean) == 12 and all(c in _JUMPER_HEX for c in cs_clean):
                                card_mappings[int(ant)] = cs_clean
                    logger.debug(f"单端口模式已用硬件读值初始化基底: {sum(1 for v in card_mappings.values() if v)} 路有卡")
            except Exception as e:
                logger.warning(f"单端口模式读取硬件基底失败（将使用 dtu_config 兜底）: {e}")

            # 第二步：用 dtu_config 期望值覆盖（平台下发的才是权威，硬件基底只补缺失项）
            # 注意：dtu_config 中已有但硬件读不到的端口（比如刚写入、读延迟），也必须强制合入，防止回擦
            if panel_id:
                dtu_base = _build_card_mappings_for_panel(panel_id)
                for ant, v in dtu_base.items():
                    if v is not None:
                        card_mappings[ant] = v
                logger.debug(f"单端口模式 panel={panel_id} dtu_config 期望合入: {sum(1 for v in dtu_base.values() if v)} 路")

            # 第三步：最后覆盖目标端口（用户要设置/清除的值优先级最高）
            if card_uid:
                uid = str(card_uid).strip().upper().replace(':', '').replace(' ', '')
                if len(uid) != 12 or not all(c in _JUMPER_HEX for c in uid):
                    return jsonify({'success': False, 'message': f'卡号必须是12位十六进制: {card_uid}'}), 400
            else:
                uid = None
            try:
                card_mappings[int(port_id)] = uid
            except (ValueError, TypeError):
                return jsonify({'success': False, 'message': f'port_id 非法: {port_id}'}), 400

        # 转换 key 为 int
        normalized = {}
        for k, v in card_mappings.items():
            try:
                port = int(k)
            except (ValueError, TypeError):
                return jsonify({'success': False, 'message': f'端口编号非法: {k}'}), 400
            if not (1 <= port <= 24):
                return jsonify({'success': False, 'message': f'端口编号必须在1-24: {port}'}), 400
            normalized[port] = v

        result = modbus_client.set_card_mapping(device_address, normalized, timeout=timeout)

        if 'error' in result:
            return jsonify({
                'success': False,
                'message': result['error'],
                'raw_data': result.get('raw_data', '')
            }), 400

        # 硬件写入成功：同步更新本地 port_state 期望值 + 持久化 dtu_config
        # 1. 先通过 device_address 反查 panel_id
        panel_id_by_addr = None
        for pid, cfg in panel_config.items():
            if cfg.get('address') == device_address:
                panel_id_by_addr = pid
                break
        # 单端口模式下若传入了 panel_id，优先用传入值
        panel_target = _resolve_panel_id(data.get('panel_id')) or panel_id_by_addr

        warnings = []
        cards_written = result.get('cards_written', {})
        if panel_target:
            port_state.setdefault(panel_target, {})
            for port_id, uid in cards_written.items():
                port_id = int(port_id)
                port_state[panel_target].setdefault(port_id, {
                    'last_uid': None, 'expected_uid': None, 'alarm_count': 0
                })
                # 规范化为 12 位大写 hex 或 None
                if uid:
                    clean_uid = str(uid).strip().upper().replace(':', '').replace(' ', '')
                    if len(clean_uid) == 12 and all(c in _JUMPER_HEX for c in clean_uid):
                        expected_uid = clean_uid
                    else:
                        expected_uid = None
                else:
                    expected_uid = None
                port_state[panel_target][port_id]['expected_uid'] = expected_uid
                # 持久化到 dtu_config.json（内部 12 位）
                dtu_config.setdefault('port_mappings', {}).setdefault(panel_target, {})
                dtu_config['port_mappings'][panel_target][str(port_id)] = expected_uid
            save_dtu_config()
            logger.info(f"卡号设置页 面板{panel_target} 已同步本地期望值: {len(cards_written)} 路")
        else:
            warnings.append(f"未找到 device_address={device_address} 对应的面板，本地期望值未更新（仅硬件已生效）")

        return jsonify({'success': True, 'data': result, 'warnings': warnings})

    except Exception as e:
        logger.error(f'设置卡号失败: {str(e)}')
        return jsonify({'success': False, 'message': str(e)}), 500


@app.route('/api/modbus/read_registers', methods=['POST'])
def modbus_read_registers():
    """读取保持寄存器

    请求参数:
    {
        "device_address": 1,
        "start_address": 2,       // 起始地址 (十六进制如0x0002或十进制如2)
        "quantity": 4,            // 寄存器数量
        "timeout": 1.0
    }
    """
    try:
        data = request.json
        device_address = data.get('device_address', 1)
        start_address = data.get('start_address', 0)
        quantity = data.get('quantity', 1)
        timeout = data.get('timeout')

        # 支持十六进制字符串
        if isinstance(start_address, str):
            start_address = int(start_address, 16)
        if isinstance(device_address, str):
            device_address = int(device_address, 16)

        if not (isinstance(serial_client.get_status(), dict) and serial_client.get_status().get("connected", False)):
            return jsonify({
                'success': False,
                'message': '串口未连接'
            }), 400

        result = modbus_client.read_holding_registers(
            device_address=device_address,
            start_address=start_address,
            quantity=quantity,
            timeout=timeout
        )

        if 'error' in result:
            return jsonify({
                'success': False,
                'message': result['error'],
                'raw_data': result.get('raw_data', '')
            }), 400

        return jsonify({
            'success': True,
            'data': result
        })

    except Exception as e:
        logger.error(f'读取寄存器失败: {str(e)}')
        return jsonify({
            'success': False,
            'message': str(e)
        }), 500


@app.route('/api/modbus/write_register', methods=['POST'])
def modbus_write_register():
    """写单个寄存器

    请求参数:
    {
        "device_address": 1,
        "register_address": 1,    // 寄存器地址
        "value": 256,             // 写入的值
        "timeout": 1.0
    }
    """
    try:
        data = request.json
        device_address = data.get('device_address', 1)
        register_address = data.get('register_address', 1)
        value = data.get('value', 0)
        timeout = data.get('timeout')

        if not (isinstance(serial_client.get_status(), dict) and serial_client.get_status().get("connected", False)):
            return jsonify({
                'success': False,
                'message':'串口未连接'
            }), 400

        result = modbus_client.write_single_register(
            device_address=device_address,
            register_address=register_address,
            value=value,
            timeout=timeout
        )

        if 'error' in result:
            return jsonify({
                'success': False,
                'message': result['error'],
                'raw_data': result.get('raw_data', '')
            }), 400

        return jsonify({
            'success': True,
            'data': result
        })

    except Exception as e:
        logger.error(f'写寄存器失败: {str(e)}')
        return jsonify({
            'success': False,
            'message': str(e)
        }), 500


@app.route('/api/modbus/set_rgb_led', methods=['POST'])
def modbus_set_rgb_led():
    """设置RGB灯状态

    请求参数:
    {
        "device_address": 1,
        "led_number": 1,          // 灯编号 (1-24)
        "color": 1,               // 颜色: 0=灭, 1=红灯, 2=绿灯, 3=蓝灯
        "timeout": 1.0
    }
    """
    try:
        data = request.json
        device_address = data.get('device_address', 1)
        led_number = data.get('led_number', 1)
        color = data.get('color', 0)
        timeout = data.get('timeout')

        if not (isinstance(serial_client.get_status(), dict) and serial_client.get_status().get("connected", False)):
            return jsonify({
                'success': False,
                'message': '串口未连接'
            }), 400

        result = modbus_client.set_rgb_led(
            device_address=device_address,
            led_number=led_number,
            color=color,
            timeout=timeout
        )

        if 'error' in result:
            return jsonify({
                'success': False,
                'message': result['error'],
                'raw_data': result.get('raw_data', '')
            }), 400

        # 按设备地址更新 LED 状态追踪
        if device_address not in led_states:
            led_states[device_address] = {}
        led_states[device_address][led_number] = color
        _refresh_current_screen_panel()

        return jsonify({
            'success': True,
            'data': result
        })

    except Exception as e:
        logger.error(f'设置RGB灯失败: {str(e)}')
        return jsonify({
            'success': False,
            'message': str(e)
        }), 500


# ========== 测试注入 API（模拟串口假数据，用于告警/同步映射端到端测试） ==========

@app.route('/api/test/inject_cards', methods=['POST'])
def test_inject_cards():
    """注入假卡号，绕过真实串口。

    请求 body:
    {
      "cards": {
        "2": {"1": "aabbccddeeff", "5": null, "12": "112233445566"}
      }
    }
    key 为设备地址（Modbus 从机地址），value 为 {port_id: hex12|null}。
    调用后轮询将读到构造的卡号，触发 event/alarm 流程。
    """
    try:
        data = request.json or {}
        raw = data.get('cards')
        if raw is None:
            modbus_client.test_cards = None
            return jsonify({'success': True, 'message': '注入已清空，恢复真实串口'})

        parsed = {}
        for addr_str, port_map in raw.items():
            addr = int(addr_str)
            pm = {}
            for pid_str, hex_str in (port_map or {}).items():
                pid = int(pid_str)
                if hex_str in (None, '', 'null'):
                    pm[pid] = None
                else:
                    s = hex_str.lower()
                    if len(s) != 12:
                        return jsonify({'success': False, 'message': f'hex 必须 12 字符: addr={addr} port={pid}'}), 400
                    bytes.fromhex(s)  # 校验
                    pm[pid] = s
            parsed[addr] = pm

        modbus_client.test_cards = parsed
        return jsonify({'success': True, 'test_cards': {
            str(a): {str(p): v for p, v in m.items()} for a, m in parsed.items()
        }})
    except Exception as e:
        return jsonify({'success': False, 'message': str(e)}), 400


@app.route('/api/test/inject_cards', methods=['GET'])
def test_inject_cards_get():
    """查看当前注入状态"""
    tc = modbus_client.test_cards
    if tc is None:
        return jsonify({'success': True, 'injected': False})
    return jsonify({
        'success': True, 'injected': True,
        'cards': {str(a): {str(p): v for p, v in m.items()} for a, m in tc.items()}
    })


@app.route('/api/modbus/scan', methods=['POST'])
def modbus_scan_devices():
    """扫描在线设备

    请求参数:
    {
        "max_address": 247,       // 最大设备地址
        "timeout": 0.2            // 单个设备超时时间
    }
    """
    try:
        data = request.json or {}
        max_address = data.get('max_address', 247)
        timeout = data.get('timeout', 0.2)

        if not (isinstance(serial_client.get_status(), dict) and serial_client.get_status().get("connected", False)):
            return jsonify({
                'success': False,
                'message': '串口未连接'
            }), 400

        # 异步扫描可能更好，但这里先同步实现
        result = modbus_client.scan_devices(max_address)

        return jsonify({
            'success': True,
            'devices': result
        })

    except Exception as e:
        logger.error(f'扫描设备失败: {str(e)}')
        return jsonify({
            'success': False,
            'message': str(e)
        }), 500


# ========== 地址配置协议 API ==========

@app.route('/api/modbus/broadcast_query', methods=['POST'])
def modbus_broadcast_query():
    """发送广播查询指令"""
    try:
        data = request.json or {}
        timeout = data.get('timeout')

        if not (isinstance(serial_client.get_status(), dict) and serial_client.get_status().get("connected", False)):
            return jsonify({'success': False, 'message': '串口未连接'}), 400

        responses = address_config.broadcast_query(timeout)
        assign_results = []
        if responses:
            assign_results = address_config.process_responses(responses)
            save_device_config()
            sync_panel_config_from_results(assign_results)
        return jsonify({
            'success': True,
            'responses': responses,
            'assign_results': assign_results,
            'count': len(responses)
        })

    except Exception as e:
        logger.error(f'广播查询失败: {str(e)}')
        return jsonify({'success': False, 'message': str(e)}), 500


@app.route('/api/modbus/auto_configure', methods=['POST'])
def modbus_auto_configure():
    """自动配置设备地址"""
    try:
        data = request.json or {}
        timeout = data.get('timeout')

        if not (isinstance(serial_client.get_status(), dict) and serial_client.get_status().get("connected", False)):
            return jsonify({'success': False, 'message': '串口未连接'}), 400

        result = address_config.auto_configure(timeout)
        if result.get('success') and (result.get('discovered', 0) > 0 or result.get('assigned', 0) > 0):
            save_device_config()
            sync_panel_config_from_results(result.get('results', []))
        return jsonify(result)

    except Exception as e:
        logger.error(f'自动配置失败: {str(e)}')
        return jsonify({'success': False, 'message': str(e)}), 500


@app.route('/api/modbus/stored_devices', methods=['GET'])
def get_stored_devices():
    """获取已注册线架列表（地址↔UID 绑定 + 在线/缺失状态）"""
    devices = address_config.get_stored_devices()
    now = time.time()
    online_threshold = 60  # 60 秒内被轮询到视为在线

    panels = []
    for uid, addr in devices.items():
        pid = _panel_id_for_address(addr)
        ps = port_state.get(pid, {})
        last_seen = device_last_seen.get(pid) or device_last_seen.get(uid)
        recent = bool(last_seen) and (now - last_seen) < online_threshold
        missing = panel_fail_count.get(pid, 0) > 0
        status = 'online' if (recent and not missing) else ('missing' if missing else 'offline')
        panels.append({
            'uid': uid,
            'address': addr,
            'online': status == 'online',
            'panel_id': pid,
            'status': status,
            'last_seen': last_seen,
            'port_count': len(ps),
            'connected_count': sum(1 for p in ps.values() if p.get('last_uid')),
            'alarm_count': sum(1 for p in ps.values() if p.get('alarm_count', 0) > 0),
        })

    return jsonify({
        'success': True,
        'devices': devices,
        'panels': panels,
        'address_range': {'start': _address_range()[0], 'end': _address_range()[1]},
        'scan': _panel_scan_state
    })


@app.route('/api/modbus/stored_devices', methods=['POST'])
def add_stored_device():
    """添加已存储的设备"""
    try:
        data = request.json
        uid = data.get('uid', '').lower()
        address = data.get('address', 1)

        if len(uid) != 24:
            return jsonify({'success': False, 'message': 'UID长度必须是24个十六进制字符'}), 400

        address_config.add_stored_device(uid, address)
        save_device_config()
        return jsonify({'success': True, 'message': f'已添加设备: UID={uid}, 地址={address}'})

    except Exception as e:
        return jsonify({'success': False, 'message': str(e)}), 500


@app.route('/api/panel/unbind', methods=['POST'])
def panel_unbind():
    """解除线架绑定（仅解除；线架仍在总线上时，下轮地址段扫描会重新识别绑定）"""
    try:
        data = request.json or {}
        addr = data.get('address')
        panel_id = data.get('panel_id')
        if addr is None and panel_id:
            cfg = panel_config.get(panel_id)
            if cfg:
                addr = cfg.get('address')
            elif isinstance(panel_id, str) and panel_id.rsplit('_', 1)[-1].isdigit():
                addr = int(panel_id.rsplit('_', 1)[-1])
        if not isinstance(addr, int):
            return jsonify({'success': False, 'message': '缺少有效的 address 或 panel_id'}), 400

        uid = _binding_uid_for_address(addr)
        if uid:
            address_config.stored_devices.pop(uid, None)
            save_device_config()

        pid = panel_id if (panel_id and panel_id in panel_config) else _panel_id_for_address(addr)
        panel_config.pop(pid, None)
        port_state.pop(pid, None)
        panel_fail_count.pop(pid, None)
        device_last_seen.pop(pid, None)
        if uid:
            device_last_seen.pop(uid, None)
        logger.info(f"已解除线架绑定: 地址={addr} UID={uid or '无'}")
        try:
            dtu_publish_panel_status(pid, addr, None, online=False)
        except Exception:
            pass
        return jsonify({
            'success': True,
            'message': f"已解除地址 {addr} 的绑定" + (f"（UID={uid}）" if uid else "（无绑定记录）"),
            'address': addr,
            'uid': uid
        })
    except Exception as e:
        logger.error(f"解除线架绑定失败: {e}")
        return jsonify({'success': False, 'message': str(e)}), 500


def _run_panel_scan():
    """后台扫描地址段内全部未绑定地址（手动触发）"""
    global _panel_scan_state
    _panel_scan_state = {'running': True, 'found': [], 'started_at': time.time(),
                         'finished_at': None, 'error': None}
    try:
        with address_config.config_lock:
            start, end = _address_range()
            bound_addrs = set(address_config.get_stored_devices().values())
            for addr in range(start, end + 1):
                if addr in bound_addrs:
                    continue
                result = modbus_client.read_all_antenna_cards(addr, uid=None, timeout=PANEL_PROBE_TIMEOUT)
                if 'error' not in result:
                    new_uid = (result.get('panel_uid') or '').lower()
                    if new_uid and _register_new_panel(addr, new_uid, result):
                        _panel_scan_state['found'].append({'address': addr, 'uid': new_uid})
                        bound_addrs.add(addr)
                time.sleep(0.05)
    except Exception as e:
        logger.error(f"线架扫描失败: {e}")
        _panel_scan_state['error'] = str(e)
    finally:
        _panel_scan_state['running'] = False
        _panel_scan_state['finished_at'] = time.time()
        logger.info(f"线架扫描完成: 发现 {len(_panel_scan_state.get('found', []))} 台")


@app.route('/api/panel/scan', methods=['POST'])
def panel_scan():
    """手动扫描地址段内未绑定地址，发现并注册新线架"""
    if _panel_scan_state.get('running'):
        return jsonify({'success': False, 'message': '扫描正在进行中，请稍候'}), 409
    threading.Thread(target=_run_panel_scan, daemon=True).start()
    return jsonify({'success': True, 'message': '已开始扫描地址段内未绑定地址'})


@app.route('/api/panel/scan_status', methods=['GET'])
def panel_scan_status():
    """查询扫描进度/结果"""
    return jsonify({'success': True, 'scan': _panel_scan_state})
    """从文件加载设备配置"""
    try:
        data = request.json
        filepath = data.get('filepath', '/tmp/modbus_devices.json')
        success = address_config.load_config(filepath)
        return jsonify({'success': success, 'devices': address_config.get_stored_devices()})
    except Exception as e:
        return jsonify({'success': False, 'message': str(e)}), 500


@app.route('/api/modbus/save_config', methods=['POST'])
def modbus_save_config():
    """保存设备配置到文件"""
    try:
        data = request.json
        filepath = data.get('filepath', '/tmp/modbus_devices.json')
        success = address_config.save_config(filepath)
        return jsonify({'success': success, 'message': f'配置已保存到: {filepath}' if success else '保存失败'})
    except Exception as e:
        return jsonify({'success': False, 'message': str(e)}), 500


@app.route('/api/modbus/confirm_devices', methods=['POST'])
def confirm_devices():
    """手动触发对所有已存储设备的确认"""
    try:
        devices = address_config.get_stored_devices()
        if not devices:
            return jsonify({'success': False, 'message': '没有已存储的设备'}), 400

        if not (isinstance(serial_client.get_status(), dict) and serial_client.get_status().get("connected", False)):
            return jsonify({'success': False, 'message': '串口未连接'}), 400

        results = []
        for uid_hex, addr in devices.items():
            try:
                uid_bytes = bytes.fromhex(uid_hex)
                cmd = build_confirm_address(addr, uid_bytes)
                success, msg = serial_client.send_raw(cmd)
                logger.info(f"确认设备 地址={addr}: {'成功' if success else '失败 ' + msg}")
                results.append({'address': addr, 'uid': uid_hex, 'success': success, 'message': msg})
            except Exception as e:
                results.append({'address': addr, 'uid': uid_hex, 'success': False, 'message': str(e)})
            time.sleep(0.1)

        return jsonify({'success': True, 'results': results, 'count': len(results)})
    except Exception as e:
        return jsonify({'success': False, 'message': str(e)}), 500


# 端口状态追踪 - 用于存储每个端口的事件状态
port_event_history = []  # 存储最近的端口事件


@app.route('/api/port/status', methods=['GET'])
def get_port_status():
    """获取所有端口状态"""
    return jsonify({'success': True, 'port_state': port_state})


@app.route('/api/port/events', methods=['GET'])
def get_port_events():
    """获取端口事件历史"""
    limit = request.args.get('limit', 100, type=int)
    return jsonify({
        'success': True,
        'events': port_event_history[-limit:]
    })


@app.route('/api/port/clear_events', methods=['POST'])
def clear_port_events():
    """清除端口事件历史"""
    global port_event_history
    port_event_history = []
    return jsonify({'success': True, 'message': '事件历史已清除'})


# 设备最后响应时间跟踪
device_last_seen = {}

@app.route('/api/panel/status', methods=['GET'])
def get_panel_status():
    """获取所有面板状态，包含每个端口的连接状态"""
    now = time.time()
    PANEL_OFFLINE_TIMEOUT = 60

    panel_status = {}
    for panel_id, ports in port_state.items():
        port_count = len(ports)
        alarm_count = sum(1 for p in ports.values() if p.get('alarm_count', 0) > 0)
        connected_count = sum(1 for p in ports.values() if p.get('last_uid'))
        panel_ports = {}
        for port_id, p in ports.items():
            last_uid = p.get('last_uid')
            expected_uid = p.get('expected_uid')
            last_polled_at = p.get('last_polled_at')
            if not last_polled_at:
                status = 'UNKNOWN'
            elif not last_uid:
                # 有期望但读不到卡：告警未插；无期望：正常空闲
                status = 'ILLEGAL_DISCONNECT' if expected_uid else 'DISCONNECTED'
            elif expected_uid and last_uid != expected_uid:
                status = 'ILLEGAL_CONNECT'
            else:
                status = 'CONNECTED'
            panel_ports[port_id] = {
                'status': status,
                'jumper_uid': last_uid or None,
                'expected_uid': expected_uid or None,
                'alarm_count': p.get('alarm_count', 0)
            }
        panel_status[panel_id] = {
            'panel_id': panel_id,
            'port_count': port_count,
            'connected_count': connected_count,
            'alarm_count': alarm_count,
            'status': 'online' if connected_count > 0 else 'offline',
            'ports': panel_ports
        }
    for panel_id, cfg in panel_config.items():
        last_seen = device_last_seen.get(panel_id, 0)
        is_online = (now - last_seen) < PANEL_OFFLINE_TIMEOUT
        if panel_id in panel_status:
            panel_status[panel_id].update({
                'address': cfg.get('address'),
                'position': cfg.get('position'),
                'panel_uid': cfg.get('panel_uid'),
                'status': 'online' if is_online else 'offline'
            })
        else:
            panel_status[panel_id] = {
                'panel_id': panel_id,
                'address': cfg.get('address'),
                'position': cfg.get('position'),
                'panel_uid': cfg.get('panel_uid'),
                'port_count': 0,
                'connected_count': 0,
                'alarm_count': 0,
                'status': 'online' if is_online else 'offline',
                'ports': {}
            }
    return jsonify({'success': True, 'panels': panel_status})


# LED 状态追踪 (按设备地址跟踪每个灯的最后设置状态)
# 结构: {device_address: {port_id: color}}, color: 0=off, 1=red, 2=green, 3=blue
led_states = {}

# Nextion 串口屏网口图片与 LED 颜色的映射关系
# 屏幕图片定义: 0=灰(灭), 1=蓝, 2=红, 3=绿
# 后端 LED 颜色定义: 0=灭, 1=红, 2=绿, 3=蓝
LED_COLOR_TO_PIC = {0: 0, 1: 2, 2: 3, 3: 1}


@app.route('/api/modbus/led_status', methods=['GET'])
def get_led_status():
    """获取 LED 状态，支持按设备地址过滤"""
    device_address = request.args.get('device_address', type=int)
    if device_address is not None:
        return jsonify({
            'success': True,
            'device_address': device_address,
            'leds': led_states.get(device_address, {})
        })
    return jsonify({'success': True, 'leds': led_states})


@app.route('/api/modbus/set_all_leds', methods=['POST'])
def set_all_leds():
    """批量设置 LED
    请求: {"device_address": 1, "color": 1}
    设置所有 24 个 LED 到指定颜色
    """
    try:
        data = request.json
        device_address = data.get('device_address', 1)
        color = data.get('color', 0)
        timeout = data.get('timeout')

        if not (isinstance(serial_client.get_status(), dict) and serial_client.get_status().get("connected", False)):
            return jsonify({'success': False, 'message': '串口未连接'}), 400

        results = []
        if device_address not in led_states:
            led_states[device_address] = {}
        for led_num in range(1, 25):
            result = modbus_client.set_rgb_led(
                device_address=device_address,
                led_number=led_num,
                color=color,
                timeout=timeout
            )
            if 'error' in result:
                results.append({'led': led_num, 'success': False, 'error': result['error']})
            else:
                results.append({'led': led_num, 'success': True})
                led_states[device_address][led_num] = color

        _refresh_current_screen_panel()
        return jsonify({'success': True, 'results': results})

    except Exception as e:
        logger.error(f'批量设置LED失败: {str(e)}')
        return jsonify({'success': False, 'message': str(e)}), 500


# 在 set_rgb_led 中更新 LED 状态追踪
# 不再需要静态文件目录，前端由nginx提供服务


# ========== DTU MQTT协议配置API ==========

@app.route('/api/dtu/config', methods=['GET'])
def get_dtu_config():
    """获取DTU配置"""
    return jsonify({
        'success': True,
        'data': dtu_config
    })


@app.route('/api/dtu/config', methods=['POST'])
def update_dtu_config():
    """更新DTU配置"""
    try:
        data = request.json
        old_config = dtu_config.copy()

        # 更新配置项
        if 'topic_prefix' in data:
            dtu_config['topic_prefix'] = data['topic_prefix']
        if 'customer_id' in data:
            dtu_config['customer_id'] = data['customer_id']
        if 'dtu_id' in data:
            dtu_config['dtu_id'] = data['dtu_id']
        if 'firmware_version' in data:
            dtu_config['firmware_version'] = data['firmware_version']
        if 'hardware_version' in data:
            dtu_config['hardware_version'] = data['hardware_version']
        if 'heartbeat_interval' in data:
            dtu_config['heartbeat_interval'] = data['heartbeat_interval']
        if 'enabled' in data:
            dtu_config['enabled'] = data['enabled']
        if 'address_range' in data:
            rng = data['address_range']
            err = None
            if not isinstance(rng, dict):
                err = 'address_range 必须是对象'
            else:
                start, end = rng.get('start'), rng.get('end')
                if not isinstance(start, int) or not isinstance(end, int):
                    err = 'address_range.start/end 必须是整数'
                elif not (1 <= start <= end <= 247):
                    err = '地址段需满足 1 <= 起始 <= 结束 <= 247'
            if err:
                return jsonify({'success': False, 'message': err}), 400
            dtu_config['address_range'] = {'start': int(rng['start']), 'end': int(rng['end'])}

        # 如果MQTT已连接且主题配置发生变化，重新订阅
        if mqtt_status and dtu_config.get('enabled'):
            old_control_topic = build_dtu_topic(
                old_config.get('customer_id', DEFAULT_CUSTOMER_ID),
                'dtu',
                old_config.get('dtu_id', DEFAULT_DTU_ID),
                'control'
            )
            new_control_topic = build_dtu_topic(
                dtu_config['customer_id'],
                'dtu',
                dtu_config['dtu_id'],
                'control'
            )

            if old_control_topic != new_control_topic:
                # 取消旧订阅，订阅新主题
                mqtt_client.unsubscribe(old_control_topic)
                mqtt_client.subscribe(new_control_topic)
                logger.info(f"控制主题已更新: {old_control_topic} -> {new_control_topic}")

                # 重新发送注册消息
                dtu_register()

        # 持久化 DTU 配置（此前仅改内存，重启会丢）
        save_dtu_config()

        return jsonify({
            'success': True,
            'message': 'DTU配置已更新',
            'data': dtu_config
        })
    except Exception as e:
        logger.error(f"更新DTU配置失败: {str(e)}")
        return jsonify({'success': False, 'message': str(e)}), 500


@app.route('/api/dtu/register', methods=['POST'])
def manual_dtu_register():
    """手动触发DTU注册"""
    try:
        if not mqtt_status:
            return jsonify({'success': False, 'message': 'MQTT未连接'}), 400

        success = dtu_register()
        if success:
            return jsonify({'success': True, 'message': '注册消息已发送'})
        else:
            return jsonify({'success': False, 'message': '注册消息发送失败'}), 500
    except Exception as e:
        logger.error(f"手动触发DTU注册失败: {str(e)}")
        return jsonify({'success': False, 'message': str(e)}), 500


_cpu_last_times = None


def _get_cpu_usage():
    """CPU 使用率 (psutil 优先，无 psutil 时回退读 /proc/stat 计算瞬时差值)"""
    global _cpu_last_times
    try:
        import psutil
        return psutil.cpu_percent(interval=None)
    except Exception:
        pass
    try:
        with open('/proc/stat') as f:
            fields = f.readline().split()
        if len(fields) < 5 or not fields[0].startswith('cpu'):
            return None
        vals = [int(x) for x in fields[1:]]
        idle = vals[3] + (vals[4] if len(vals) > 4 else 0)
        total = sum(vals)
        if _cpu_last_times:
            dtotal = total - _cpu_last_times[0]
            didle = idle - _cpu_last_times[1]
            if dtotal > 0:
                pct = round((1.0 - didle / dtotal) * 100, 1)
                _cpu_last_times = (total, idle)
                return pct
        _cpu_last_times = (total, idle)
        return None
    except Exception:
        return None


def _get_memory_usage():
    """内存使用率 (psutil 优先，无 psutil 时回退读 /proc/meminfo)"""
    try:
        import psutil
        return psutil.virtual_memory().percent
    except Exception:
        pass
    try:
        meminfo = {}
        with open('/proc/meminfo') as f:
            for line in f:
                parts = line.split(':')
                if len(parts) == 2:
                    try:
                        meminfo[parts[0].strip()] = int(parts[1].split()[0])
                    except (ValueError, IndexError):
                        continue
        total = meminfo.get('MemTotal', 0)
        available = meminfo.get('MemAvailable')
        if available is None:
            available = meminfo.get('MemFree', 0)
        if total > 0:
            return round((1.0 - available / total) * 100, 1)
        return None
    except Exception:
        return None


@app.route('/api/dtu/status', methods=['GET'])
def get_dtu_status():
    """获取DTU状态"""
    try:
        # 获取串口状态
        serial_st = serial_client.get_status()

        # 获取面板状态
        devices = address_config.get_stored_devices()

        # 主板温度: 优先外部上报，否则本地读取
        dtu_temperature = env_sensor_data.get('dtu_temperature')
        if dtu_temperature is None:
            try:
                import psutil
                temps = psutil.sensors_temperatures(fahrenheit=False) or {}
                for chip_name, entries in temps.items():
                    for entry in entries:
                        if entry.current and entry.current > 0:
                            dtu_temperature = round(entry.current, 1)
                            break
                    if dtu_temperature is not None:
                        break
            except Exception:
                pass
            if dtu_temperature is None:
                import glob as _glob
                for tz in sorted(_glob.glob('/sys/class/thermal/thermal_zone*/temp')):
                    try:
                        with open(tz) as f:
                            v = int(f.read().strip())
                            if v > 0:
                                dtu_temperature = round(v / 1000.0, 1)
                                break
                    except Exception:
                        continue

        status = {
            'dtu_id': dtu_config.get('dtu_id'),
            'mqtt_connected': mqtt_status,
            'serial_connected': isinstance(serial_st, dict) and serial_st.get('connected', False),
            'dtu_enabled': dtu_config.get('enabled', True),
            'topic_prefix': dtu_config.get('topic_prefix'),
            'customer_id': dtu_config.get('customer_id'),
            'panel_count': len(devices),
            'cpu_usage': _get_cpu_usage(),
            'memory_usage': _get_memory_usage(),
            'temperature': dtu_temperature,
            'dtu_temperature': dtu_temperature,
            'firmware_version': dtu_config.get('firmware_version', 'v1.0.0'),
            'topics': {
                'register': build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'register'),
                'status': build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'status'),
                'control': build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'control'),
                'response': build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'response'),
                'event': build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'event'),
                'alarm': build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'alarm')
            }
        }

        return jsonify({'success': True, 'data': status})
    except Exception as e:
        logger.error(f"获取DTU状态失败: {str(e)}")
        return jsonify({'success': False, 'message': str(e)}), 500


@app.route('/api/dtu/control', methods=['POST'])
def dtu_control():
    """发送DTU控制命令（HTTP 入口，复用 dtu_handle_control 逻辑）"""
    try:
        data = request.json or {}
        # 兼容两种入参格式:
        #   1) {"command": "...", "target": "...", "params": {...}}  简洁格式
        #   2) {"payload": {"command": "...", "target": "...", "params": {...}}}  MQTT envelope 格式
        inner = data.get('payload') if isinstance(data.get('payload'), dict) else data
        command = inner.get('command')

        # REBOOT 走快速通道立即执行
        if command == 'REBOOT':
            import subprocess
            logger.warning("执行系统重启命令")
            threading.Thread(target=lambda: (
                time.sleep(1),
                subprocess.run(['reboot'], capture_output=True)
            ), daemon=True).start()
            return jsonify({'success': True, 'message': '系统正在重启...'})

        # 其他命令委托给 MQTT 处理器（构造 MQTT envelope 后调用）
        mqtt_envelope = {
            'msg_id': data.get('msg_id', f"http_{int(time.time() * 1000)}_{uuid.uuid4().hex[:6]}"),
            'timestamp': data.get('timestamp', int(time.time() * 1000)),
            'dtu_id': data.get('dtu_id', dtu_config.get('dtu_id')),
            'type': 'CONTROL',
            'payload': {
                'command': command,
                'target': inner.get('target'),
                'params': inner.get('params', {})
            }
        }
        # 调用 MQTT 处理器（其内部会发送响应到 dtu/.../response 主题）
        dtu_handle_control('http/control', mqtt_envelope)
        # 如果命令是 QUERY_JUMPER_STATUS / QUERY_ENV_SENSOR / QUERY_DTU_STATUS，
        # 实际响应已发布到对应主题，HTTP 端点仅返回成功标记
        if command in ('QUERY_JUMPER_STATUS', 'QUERY_ENV_SENSOR', 'QUERY_DTU_STATUS'):
            return jsonify({
                'success': True,
                'message': f'{command} 已发布到 MQTT 主题'
            })
        # 其他命令: 从 MQTT 主题同步拉取最新响应（简化处理：直接返回已发布标记）
        return jsonify({
            'success': True,
            'message': f'{command} 命令已下发，等待 MQTT 响应'
        })
    except Exception as e:
        logger.error(f"DTU控制命令失败: {str(e)}")
        return jsonify({'success': False, 'message': str(e)}), 500


# OTA状态存储
ota_status = {
    'status': 'IDLE',  # IDLE, DOWNLOADING, VERIFYING, FLASHING, SUCCESS, FAILED
    'progress': 0,
    'firmware_version': None,
    'target_version': None,
    'error_code': None,
    'error_message': None,
    'last_update': None
}


@app.route('/api/dtu/ota_detect', methods=['POST'])
def ota_detect():
    """检测固件包信息（自动下载并解析 manifest）"""
    try:
        url = request.json.get('url', '')
        if not url:
            return jsonify({'success': False, 'message': '请提供固件 URL'}), 400

        import urllib.request, tempfile, tarfile, json, hashlib
        tmp = tempfile.mktemp(suffix='.tar.gz')
        try:
            urllib.request.urlretrieve(url, tmp)
        except Exception as e:
            return jsonify({'success': False, 'message': f'下载失败: {str(e)}'}), 400

        file_size = os.path.getsize(tmp)
        h = hashlib.md5()
        with open(tmp, 'rb') as f:
            for chunk in iter(lambda: f.read(65536), b''):
                h.update(chunk)
        md5sum = h.hexdigest()

        version = ''
        try:
            with tarfile.open(tmp, 'r:gz') as tar:
                m = tar.extractfile('firmware/firmware.json')
                if m:
                    manifest = json.loads(m.read())
                    version = manifest.get('version', '')
        except Exception as e:
            logger.warning(f"解析 firmware.json 失败: {e}")

        os.remove(tmp)
        return jsonify({
            'success': True,
            'data': {
                'file_size': file_size,
                'checksum': md5sum,
                'checksum_type': 'MD5',
                'firmware_version': version
            }
        })
    except Exception as e:
        logger.error(f"检测固件失败: {str(e)}")
        return jsonify({'success': False, 'message': str(e)}), 500


@app.route('/api/dtu/ota_status', methods=['GET'])
def get_ota_status():
    """获取OTA升级状态"""
    try:
        return jsonify({
            'success': True,
            'data': {
                'current_firmware': dtu_config.get('firmware_version', 'v1.0.0'),
                'ota_status': ota_status.get('status', 'IDLE'),
                'ota_progress': ota_status.get('progress', 0),
                'target_version': ota_status.get('target_version'),
                'error_code': ota_status.get('error_code'),
                'error_message': ota_status.get('error_message'),
                'last_update': ota_status.get('last_update')
            }
        })
    except Exception as e:
        logger.error(f"获取OTA状态失败: {str(e)}")
        return jsonify({'success': False, 'message': str(e)}), 500


def handle_ota_status(dtu_id, payload):
    """处理MQTT上报的OTA状态"""
    ota_status['status'] = payload.get('ota_status', 'IDLE')
    ota_status['progress'] = payload.get('ota_progress', 0)
    ota_status['firmware_version'] = payload.get('firmware_version')
    ota_status['last_update'] = time.strftime('%Y-%m-%d %H:%M:%S')
    error_code = payload.get('error_code')
    if error_code and error_code != 0:
        ota_status['error_code'] = error_code
        ota_status['error_message'] = payload.get('error_message', get_ota_error_message(error_code))
        ota_status['status'] = 'FAILED'
    elif ota_status['status'] == 'SUCCESS':
        ota_status['error_code'] = None
        ota_status['error_message'] = None
        if ota_status.get('firmware_version'):
            dtu_config['firmware_version'] = ota_status['firmware_version']
            save_dtu_config()
    logger.info(f"MQTT OTA状态更新: {ota_status['status']}, 进度: {ota_status['progress']}%")


def get_ota_error_message(error_code):
    error_messages = {1021: '已是目标版本', 1022: '校验失败', 1023: '下载失败', 1024: '写入失败', 1025: '存储空间不足'}
    return error_messages.get(error_code, f'未知错误码: {error_code}')


def _publish_ota_progress():
    """通过MQTT发布OTA进度"""
    try:
        if not _mqtt_connected():
            return
        topic = build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'status')
        payload = {
            'msg_id': f"ota_status_{int(time.time() * 1000)}",
            'timestamp': int(time.time() * 1000),
            'dtu_id': dtu_config['dtu_id'],
            'type': 'STATUS',
            'payload': {
                'ota_status': ota_status.get('status', 'IDLE'),
                'ota_progress': ota_status.get('progress', 0),
                'firmware_version': ota_status.get('target_version', ''),
                'error_code': ota_status.get('error_code', 0),
                'error_message': ota_status.get('error_message')
            }
        }
        mqtt_client.publish(topic, json.dumps(payload), qos=1)
    except Exception:
        pass


def _send_ota_error_response(error_code, original_msg_id=''):
    """通过MQTT发送OTA错误响应（1021-1025）"""
    try:
        if not _mqtt_connected():
            return
        topic = build_dtu_topic(dtu_config['customer_id'], 'dtu', dtu_config['dtu_id'], 'response')
        payload = {
            'msg_id': f"rsp_ota_{int(time.time() * 1000)}_{uuid.uuid4().hex[:6]}",
            'timestamp': int(time.time() * 1000),
            'dtu_id': dtu_config['dtu_id'],
            'type': 'RESPONSE',
            'payload': {
                'original_msg_id': original_msg_id,
                'command': 'OTA_UPGRADE',
                'success': False,
                'result': None,
                'error_code': error_code,
                'error_message': get_ota_error_message(error_code)
            }
        }
        mqtt_client.publish(topic, json.dumps(payload), qos=1)
    except Exception:
        pass


def _run_ota(params):
    """执行OTA升级（后台线程，供HTTP和MQTT共用）"""
    import subprocess, os, hashlib, shutil, tarfile, tempfile, urllib.request
    url = params['firmware_url']
    version = params['firmware_version']
    file_size = params['file_size']
    checksum = params['checksum']
    checksum_type = params.get('checksum_type', 'MD5').upper()
    force = params.get('force_upgrade', False)
    ota_status['status'] = 'DOWNLOADING'
    ota_status['progress'] = 0
    ota_status['target_version'] = version
    ota_status['error_code'] = None
    ota_status['error_message'] = None
    ota_status['last_update'] = time.strftime('%Y-%m-%d %H:%M:%S')
    _publish_ota_progress()
    try:
        tmp_dir = tempfile.mkdtemp(prefix='ota_')
        fw_path = os.path.join(tmp_dir, 'firmware.tar.gz')
        ota_status['progress'] = 5
        ota_status['last_update'] = time.strftime('%Y-%m-%d %H:%M:%S')
        logger.info(f"OTA: 开始下载固件 {url}")
        req = urllib.request.Request(url, headers={'User-Agent': 'OTA-Updater'})
        # 进度上报节流: 每 10% 或每 5 秒
        last_published_pct = 0
        last_publish_time = time.time()
        with urllib.request.urlopen(req, timeout=120) as resp:
            with open(fw_path, 'wb') as f:
                total = int(resp.headers.get('Content-Length', 0))
                downloaded = 0
                while True:
                    chunk = resp.read(65536)
                    if not chunk: break
                    f.write(chunk)
                    downloaded += len(chunk)
                    if total:
                        pct = 5 + int(downloaded / total * 30)
                        ota_status['progress'] = min(pct, 35)
                        now = time.time()
                        if pct - last_published_pct >= 10 or (now - last_publish_time) >= 5:
                            last_published_pct = pct
                            last_publish_time = now
                            ota_status['last_update'] = time.strftime('%Y-%m-%d %H:%M:%S')
                            _publish_ota_progress()
        dl_size = os.path.getsize(fw_path)
        ota_status['progress'] = 40
        ota_status['last_update'] = time.strftime('%Y-%m-%d %H:%M:%S')
        _publish_ota_progress()
        if abs(dl_size - file_size) > 1024:
            raise Exception(f"文件大小不匹配: 预期{file_size}, 实际{dl_size}")
        ota_status['status'] = 'VERIFYING'
        ota_status['progress'] = 50
        ota_status['last_update'] = time.strftime('%Y-%m-%d %H:%M:%S')
        _publish_ota_progress()
        h = hashlib.new(checksum_type)
        with open(fw_path, 'rb') as f:
            for chunk in iter(lambda: f.read(65536), b''): h.update(chunk)
        actual_checksum = h.hexdigest().lower()
        if actual_checksum != checksum.lower():
            raise Exception(f"校验和不匹配: 预期{checksum}, 实际{actual_checksum}")
        ota_status['progress'] = 60
        ota_status['last_update'] = time.strftime('%Y-%m-%d %H:%M:%S')
        _publish_ota_progress()
        extract_dir = os.path.join(tmp_dir, 'firmware')
        os.makedirs(extract_dir, exist_ok=True)
        with tarfile.open(fw_path, 'r:gz') as tar: tar.extractall(extract_dir)
        manifest_path = os.path.join(extract_dir, 'firmware', 'firmware.json')
        if not os.path.exists(manifest_path):
            raise Exception("固件包缺少 firmware.json")
        with open(manifest_path, 'r') as f: manifest = json.load(f)
        fw_version = manifest.get('version', version)
        if not force:
            current_ver = dtu_config.get('firmware_version', 'v0.0.0')
            if fw_version == current_ver:
                raise Exception(f'已是目标版本 {current_ver}')
        ota_status['status'] = 'FLASHING'
        ota_status['progress'] = 70
        ota_status['last_update'] = time.strftime('%Y-%m-%d %H:%M:%S')
        _publish_ota_progress()
        fw_root = os.path.join(extract_dir, 'firmware')
        project_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
        excludes = {'__pycache__', '.git', 'log', 'venv'}
        for root, dirs, files in os.walk(fw_root):
            rel = os.path.relpath(root, fw_root)
            if rel == '.': rel = ''
            parts = rel.split(os.sep) if rel else []
            if parts and parts[0] in excludes: continue
            for fname in files:
                if fname == 'firmware.json': continue
                src = os.path.join(root, fname)
                dst = os.path.join(project_dir, rel, fname)
                os.makedirs(os.path.dirname(dst), exist_ok=True)
                shutil.copy2(src, dst)
        ota_status['progress'] = 90
        ota_status['last_update'] = time.strftime('%Y-%m-%d %H:%M:%S')
        dtu_config['firmware_version'] = fw_version
        save_dtu_config()
        ota_status['status'] = 'SUCCESS'
        ota_status['progress'] = 100
        ota_status['firmware_version'] = fw_version
        ota_status['last_update'] = time.strftime('%Y-%m-%d %H:%M:%S')
        _publish_ota_progress()
        shutil.rmtree(tmp_dir, ignore_errors=True)
        for i in range(10, 0, -1):
            ota_status['last_update'] = time.strftime('%Y-%m-%d %H:%M:%S')
            time.sleep(1)
        logger.info("OTA: 重启服务...")
        subprocess.Popen(
            [subprocess.sys.executable, '-m', 'flask', 'run', '--host=0.0.0.0', '--port=5001'],
            cwd=os.path.dirname(os.path.abspath(__file__)),
            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
        )
        os._exit(0)
    except Exception as e:
        ota_status['status'] = 'FAILED'
        ota_status['error_message'] = str(e)
        ota_status['last_update'] = time.strftime('%Y-%m-%d %H:%M:%S')
        # 映射错误到标准错误码 (1021-1025)
        msg = str(e)
        if '校验和' in msg or 'firmware.json' in msg:
            ota_status['error_code'] = 1022
        elif '已是目标版本' in msg:
            ota_status['error_code'] = 1021
        elif '下载' in msg or 'urlopen' in msg or 'Connection' in msg or 'timeout' in msg:
            ota_status['error_code'] = 1023
        elif '磁盘' in msg or '空间' in msg or 'No space' in msg:
            ota_status['error_code'] = 1025
        elif '写入' in msg or 'flash' in msg.lower() or 'shutil' in msg:
            ota_status['error_code'] = 1024
        else:
            ota_status['error_code'] = 9999
        _publish_ota_progress()
        # 通过MQTT发送错误响应（同时适配HTTP和MQTT触发）
        _send_ota_error_response(ota_status['error_code'], params.get('_incoming_msg_id', ''))
        logger.error(f"OTA: 升级失败 - {str(e)}")
        if 'tmp_dir' in dir() and tmp_dir and os.path.exists(tmp_dir):
            shutil.rmtree(tmp_dir, ignore_errors=True)


@app.route('/api/dtu/ota_upgrade', methods=['POST'])
def trigger_ota_upgrade():
    """触发OTA升级"""
    try:
        data = request.json
        if not data:
            return jsonify({'success': False, 'message': '请求体不能为空'}), 400

        required_fields = ['firmware_url', 'firmware_version', 'file_size', 'checksum', 'checksum_type']
        missing = [f for f in required_fields if not data.get(f)]
        if missing:
            return jsonify({'success': False, 'message': f'缺少必填字段: {", ".join(missing)}'}), 400

        # 已是目标版本且未强制: 1021 (同时通过 MQTT 上报响应)
        force_upgrade = data.get('force_upgrade', False)
        current_version = dtu_config.get('firmware_version', 'v1.0.0')
        if data['firmware_version'] == current_version and not force_upgrade:
            # 通过 MQTT 上报 1021 响应 (与其他错误码一致)
            try:
                _send_ota_error_response(1021, data.get('msg_id', ''))
            except Exception:
                pass
            return jsonify({
                'success': False,
                'error_code': 1021,
                'message': f'已是目标版本: {current_version}'
            }), 400

        # 注入 _incoming_msg_id 使 MQTT 错误响应可回填
        ota_params = {**data, '_incoming_msg_id': data.get('msg_id', '')}
        t = threading.Thread(target=_run_ota, args=(ota_params,), daemon=True)
        t.start()

        return jsonify({
            'success': True,
            'message': 'OTA升级已启动',
            'data': {
                'target_version': data['firmware_version'],
                'ota_status': 'DOWNLOADING'
            }
        })
    except Exception as e:
        logger.error(f"触发OTA升级失败: {str(e)}")
        return jsonify({'success': False, 'message': str(e)}), 500


# ==================== 环境传感器 API ====================

# 环境传感器数据存储
env_sensor_data = {
    'temperature': None,          # 环境温度 (℃)
    'humidity': None,             # 环境湿度 (%)
    'dtu_temperature': None,      # DTU主板温度 (℃)
    'update_time': None,          # 数据更新时间
    'sensor_update_time': None,   # 传感器更新时间
    'connected': False            # 传感器连接状态
}

# 环境传感器告警阈值
env_sensor_threshold = {
    'temp_high': 45.0,            # 环境温度上限 (℃)
    'temp_low': -10.0,            # 环境温度下限 (℃)
    'humidity_high': 80.0,        # 环境湿度上限 (%)
    'humidity_low': 20.0,         # 环境湿度下限 (%)
    'dtu_temp_high': 70.0         # DTU主板温度上限 (℃)
}

# 环境传感器历史数据 (保留最近1000条)
env_sensor_history = []


@app.route('/api/sensor/env', methods=['GET'])
def get_env_sensor_data():
    """获取环境传感器当前数据"""
    data = dict(env_sensor_data)
    # DTU 主板温度回退: 若外部未上报，从 sysfs 本地读取
    if data.get('dtu_temperature') is None:
        try:
            import psutil
            temps = psutil.sensors_temperatures(fahrenheit=False) or {}
            for chip_name, entries in temps.items():
                for entry in entries:
                    if entry.current and entry.current > 0:
                        data['dtu_temperature'] = round(entry.current, 1)
                        break
                if data['dtu_temperature'] is not None:
                    break
        except Exception:
            pass
        if data.get('dtu_temperature') is None:
            import glob as _glob
            for tz in sorted(_glob.glob('/sys/class/thermal/thermal_zone*/temp')):
                try:
                    with open(tz) as f:
                        v = int(f.read().strip())
                        if v > 0:
                            data['dtu_temperature'] = round(v / 1000.0, 1)
                            data['update_time'] = data.get('update_time') or __import__('datetime').datetime.now().strftime('%Y-%m-%d %H:%M:%S')
                            break
                except Exception:
                    continue
    # 附加 CPU/内存使用率（始终本地读取）
    data['cpu_usage'] = _get_cpu_usage()
    data['memory_usage'] = _get_memory_usage()
    return jsonify({
        'success': True,
        'data': data
    })


@app.route('/api/sensor/threshold', methods=['GET', 'POST'])
def handle_env_sensor_threshold():
    """获取或设置环境传感器告警阈值"""
    if request.method == 'GET':
        return jsonify({
            'success': True,
            'data': env_sensor_threshold
        })
    else:
        try:
            data = request.get_json()
            for key in env_sensor_threshold.keys():
                if key in data:
                    env_sensor_threshold[key] = float(data[key])
            logger.info(f"更新环境传感器告警阈值: {env_sensor_threshold}")
            return jsonify({
                'success': True,
                'message': '阈值设置成功',
                'data': env_sensor_threshold
            })
        except Exception as e:
            logger.error(f"设置告警阈值失败: {str(e)}")
            return jsonify({'success': False, 'message': str(e)}), 400


@app.route('/api/sensor/history', methods=['GET'])
def get_env_sensor_history():
    """获取环境传感器历史数据"""
    try:
        import datetime
        # 获取查询参数
        range_param = request.args.get('range', '24h')
        start_time = request.args.get('start_time')
        end_time = request.args.get('end_time')
        limit = request.args.get('limit', 100, type=int)

        filtered_history = env_sensor_history

        # 解析range参数
        if not start_time and not end_time:
            now = datetime.datetime.now()
            if range_param == '1h':
                start_time = (now - datetime.timedelta(hours=1)).strftime('%Y-%m-%d %H:%M:%S')
            elif range_param == '6h':
                start_time = (now - datetime.timedelta(hours=6)).strftime('%Y-%m-%d %H:%M:%S')
            elif range_param == '24h':
                start_time = (now - datetime.timedelta(hours=24)).strftime('%Y-%m-%d %H:%M:%S')
            elif range_param == '7d':
                start_time = (now - datetime.timedelta(days=7)).strftime('%Y-%m-%d %H:%M:%S')
            elif range_param == '30d':
                start_time = (now - datetime.timedelta(days=30)).strftime('%Y-%m-%d %H:%M:%S')

        # 按时间过滤
        if start_time:
            filtered_history = [h for h in filtered_history if h.get('update_time') >= start_time]
        if end_time:
            filtered_history = [h for h in filtered_history if h.get('update_time') <= end_time]

        # 按时间排序 (新到旧)
        filtered_history = sorted(filtered_history, key=lambda x: x.get('update_time', ''), reverse=True)

        # 限制返回数量
        filtered_history = filtered_history[:limit]

        return jsonify({
            'success': True,
            'data': filtered_history,
            'total': len(filtered_history)
        })
    except Exception as e:
        logger.error(f"获取历史数据失败: {str(e)}")
        return jsonify({'success': False, 'message': str(e)}), 500


def update_env_sensor_data_full(temperature, humidity, dtu_temperature, sensor_update_time):
    """更新环境传感器数据 (由MQTT消息触发) - 完整版，含历史和告警"""
    import datetime
    now = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')

    env_sensor_data['temperature'] = temperature
    env_sensor_data['humidity'] = humidity
    env_sensor_data['dtu_temperature'] = dtu_temperature
    env_sensor_data['sensor_update_time'] = sensor_update_time
    env_sensor_data['update_time'] = now
    env_sensor_data['connected'] = True

    # 同步到 MQTT 上行所用的 _env_sensor_data
    _env_sensor_data['temperature'] = temperature
    _env_sensor_data['humidity'] = humidity
    _env_sensor_data['sensor_update_time'] = sensor_update_time

    # 添加到历史记录
    history_record = {
        'temperature': temperature,
        'humidity': humidity,
        'dtu_temperature': dtu_temperature,
        'sensor_update_time': sensor_update_time,
        'update_time': now
    }
    env_sensor_history.append(history_record)

    # 保留最近1000条
    if len(env_sensor_history) > 1000:
        env_sensor_history[:] = env_sensor_history[-1000:]

    # 检查告警
    check_env_sensor_alarms(temperature, humidity, dtu_temperature)

    logger.info(f"环境传感器数据更新: 温度={temperature}℃, 湿度={humidity}%, DTU温度={dtu_temperature}℃")


def dht11_data_callback(temperature, humidity):
    """DHT11 本地 GPIO 传感器数据回调。

    将读取到的温湿度更新到环境传感器数据区，并通过 MQTT 上报。
    保留已有的 dtu_temperature（主板温度），仅更新环境温湿度字段。
    若外部未上报 dtu_temperature，则从本地 sysfs 读取（与 /api/sensor/env 回退逻辑一致），
    确保历史记录中 DTU 温度字段有值。
    """
    try:
        sensor_update_time = int(time.time() * 1000)
        dtu_temperature = env_sensor_data.get('dtu_temperature')

        # DTU 主板温度回退：外部未上报时从 sysfs 本地读取，并回填 env_sensor_data
        # 否则历史记录 dtu_temperature 会一直是 None（/api/sensor/env 有回退但历史写入没有）
        if dtu_temperature is None:
            try:
                import psutil
                temps = psutil.sensors_temperatures(fahrenheit=False) or {}
                for chip_name, entries in temps.items():
                    for entry in entries:
                        if entry.current and entry.current > 0:
                            dtu_temperature = round(entry.current, 1)
                            break
                    if dtu_temperature is not None:
                        break
            except Exception:
                pass
            if dtu_temperature is None:
                import glob as _glob
                for tz in sorted(_glob.glob('/sys/class/thermal/thermal_zone*/temp')):
                    try:
                        with open(tz) as f:
                            v = int(f.read().strip())
                            if v > 0:
                                dtu_temperature = round(v / 1000.0, 1)
                                break
                    except Exception:
                        continue
            # 回填到 env_sensor_data，避免每次回调都重新读 sysfs
            if dtu_temperature is not None:
                env_sensor_data['dtu_temperature'] = dtu_temperature

        update_env_sensor_data_full(temperature, humidity, dtu_temperature, sensor_update_time)

        # 立即通过 MQTT 上报环境传感器数据
        try:
            dtu_publish_env_sensor()
        except Exception as pub_err:
            logger.warning(f"DHT11 数据 MQTT 上报失败: {pub_err}")

        logger.info(f"DHT11 本地传感器数据已处理: 温度={temperature}°C, 湿度={humidity}%")
    except Exception as e:
        logger.error(f"处理 DHT11 本地传感器数据失败: {e}")


def check_env_sensor_alarms(temperature, humidity, dtu_temperature):
    """检查环境传感器告警"""
    alarms = []

    if temperature is not None:
        if temperature > env_sensor_threshold['temp_high']:
            alarms.append({
                'type': 'temperature_high',
                'message': f'环境温度过高: {temperature}℃ (阈值: {env_sensor_threshold["temp_high"]}℃)',
                'level': 'warning'
            })
        elif temperature < env_sensor_threshold['temp_low']:
            alarms.append({
                'type': 'temperature_low',
                'message': f'环境温度过低: {temperature}℃ (阈值: {env_sensor_threshold["temp_low"]}℃)',
                'level': 'warning'
            })

    if humidity is not None:
        if humidity > env_sensor_threshold['humidity_high']:
            alarms.append({
                'type': 'humidity_high',
                'message': f'环境湿度过高: {humidity}% (阈值: {env_sensor_threshold["humidity_high"]}%)',
                'level': 'warning'
            })
        elif humidity < env_sensor_threshold['humidity_low']:
            alarms.append({
                'type': 'humidity_low',
                'message': f'环境湿度过低: {humidity}% (阈值: {env_sensor_threshold["humidity_low"]}%)',
                'level': 'warning'
            })

    if dtu_temperature is not None:
        if dtu_temperature > env_sensor_threshold['dtu_temp_high']:
            alarms.append({
                'type': 'dtu_temp_high',
                'message': f'DTU主板温度过高: {dtu_temperature}℃ (阈值: {env_sensor_threshold["dtu_temp_high"]}℃)',
                'level': 'critical'
            })

    # 发送告警通知
    for alarm in alarms:
        logger.warning(f"环境传感器告警: {alarm['message']}")
        # 可以通过WebSocket发送告警
        socketio.emit('env_sensor_alarm', alarm)


# ========== 运行数据备份 / 恢复 ==========

SYSTEM_ENV_FILE = '/etc/default/dzxj_dtu'

_SNAPSHOT_TARGETS = {
    'dtu_config': DTU_CONFIG_FILE,
    'serial_config': SERIAL_CONFIG_FILE,
    'mqtt_config': MQTT_CONFIG_FILE,
    'devices': DEVICE_CONFIG_FILE,
}


def _read_system_env():
    """读取设备环境变量文件（/etc/default/dzxj_dtu），不存在返回 None"""
    try:
        if os.path.exists(SYSTEM_ENV_FILE):
            with open(SYSTEM_ENV_FILE, 'r', encoding='utf-8') as f:
                return f.read()
    except Exception as e:
        logger.warning(f"读取环境变量文件失败: {e}")
    return None


def _collect_backup_files():
    """收集备份内容：4 个配置文件 + 系统环境变量文件（可选）"""
    files = {}
    dtu_data = None
    try:
        if os.path.exists(DTU_CONFIG_FILE):
            dtu_data = config_backup.read_json_file(DTU_CONFIG_FILE)
    except Exception as e:
        logger.warning(f"读取 dtu_config.json 失败，改用内存配置: {e}")
    files['dtu_config'] = dtu_data if isinstance(dtu_data, dict) else dict(dtu_config)

    for key, path in (('serial_config', SERIAL_CONFIG_FILE),
                      ('mqtt_config', MQTT_CONFIG_FILE),
                      ('devices', DEVICE_CONFIG_FILE)):
        data = None
        try:
            if os.path.exists(path):
                data = config_backup.read_json_file(path)
        except Exception as e:
            logger.warning(f"读取 {path} 失败: {e}")
        files[key] = data
    if not isinstance(files.get('devices'), dict):
        files['devices'] = address_config.get_stored_devices()
    files['system_env'] = _read_system_env()
    return files


def _configs_differ(a, b):
    try:
        return (json.dumps(a or {}, sort_keys=True, ensure_ascii=False)
                != json.dumps(b or {}, sort_keys=True, ensure_ascii=False))
    except Exception:
        return True


def _backup_preview(bundle):
    """备份包预览信息（导入前确认用）"""
    files = bundle.get('files') or {}
    dtu_data = files.get('dtu_config') or {}
    included = {}
    for key, val in files.items():
        if val in (None, '', {}):
            continue
        if isinstance(val, str):
            included[key] = f'{len(val)} 字节文本'
        else:
            included[key] = f'{len(json.dumps(val, ensure_ascii=False))} 字节'
    prefix = bundle.get('effective_uid_prefix')
    return {
        'created_at': bundle.get('created_at'),
        'device': bundle.get('device') or {},
        'files': included,
        'effective_uid_prefix': prefix,
        'current_dtu_id': dtu_config.get('dtu_id'),
        'backup_dtu_id': dtu_data.get('dtu_id'),
        'will_fix_uid_prefix': bool(prefix) and not dtu_data.get('uid_prefix'),
        'restart_required': isinstance(files.get('system_env'), str) and bool((files.get('system_env') or '').strip()),
        'devices_count': len(files.get('devices') or {}),
        'port_mapping_panels': len(dtu_data.get('port_mappings') or {}),
    }


def _apply_backup_bundle(bundle):
    """应用备份包：写文件 + 内存生效 + 自动重连，返回结果摘要"""
    files = bundle.get('files') or {}
    applied = []
    errors = []

    # 1) dtu_config（固化 effective_uid_prefix，保证换机后卡号前缀一致）
    dtu_data = files.get('dtu_config')
    if isinstance(dtu_data, dict):
        dtu_data = dict(dtu_data)
        prefix = (bundle.get('effective_uid_prefix') or '').strip().upper()
        if prefix and not dtu_data.get('uid_prefix'):
            dtu_data['uid_prefix'] = prefix
            applied.append(f'已固化 UID 前缀: {prefix}')
        dtu_config.update(dtu_data)
        save_dtu_config()
        applied.append('dtu_config')

    # 2) 串口配置（变化则重连）
    sc = files.get('serial_config')
    if isinstance(sc, dict):
        old_sc = load_serial_config()
        if _save_config_file(SERIAL_CONFIG_FILE, sc, '串口配置'):
            applied.append('serial_config')
        if _configs_differ(old_sc, sc):
            try:
                if _serial_connected():
                    serial_client.disconnect()
                auto_connect_serial()
            except Exception as e:
                errors.append(f'串口重连失败: {e}')

    # 3) MQTT 配置（变化则重连）
    mc = files.get('mqtt_config')
    if isinstance(mc, dict):
        old_mc = load_mqtt_config()
        if _save_config_file(MQTT_CONFIG_FILE, mc, 'MQTT配置'):
            applied.append('mqtt_config')
        if _configs_differ(old_mc, mc):
            try:
                if _mqtt_connected():
                    mqtt_client.disconnect()
                auto_connect_mqtt()
            except Exception as e:
                errors.append(f'MQTT重连失败: {e}')

    # 4) 线架绑定表（重建面板配置）
    dev = files.get('devices')
    if isinstance(dev, dict):
        if _save_config_file(DEVICE_CONFIG_FILE, dev, '设备配置'):
            applied.append('devices')
        address_config.stored_devices = {str(k).lower(): int(v) for k, v in dev.items()}
        panel_config.clear()
        port_state.clear()
        panel_fail_count.clear()
        sync_panel_config()

    # 5) 系统环境变量文件（需重启服务生效）
    restart_required = False
    env_text = files.get('system_env')
    if isinstance(env_text, str) and env_text.strip():
        try:
            with open(SYSTEM_ENV_FILE, 'w', encoding='utf-8') as f:
                f.write(env_text)
            applied.append('system_env')
            restart_required = True
        except Exception as e:
            errors.append(f'写入环境变量文件失败(需 root): {e}')

    # 6) 后台补一次注册上报
    def _post_restore_refresh():
        try:
            if _mqtt_connected():
                dtu_register()
        except Exception as e:
            logger.warning(f"恢复后注册上报失败: {e}")
    threading.Thread(target=_post_restore_refresh, daemon=True).start()

    return {'applied': applied, 'errors': errors, 'restart_required': restart_required}


@app.route('/api/backup/export', methods=['GET'])
def backup_export():
    """导出整机运行数据备份包（download=1 时作为文件下载）"""
    try:
        files = _collect_backup_files()
        bundle = config_backup.build_bundle(
            files,
            device_meta={
                'dtu_id': dtu_config.get('dtu_id'),
                'customer_id': dtu_config.get('customer_id'),
                'firmware_version': dtu_config.get('firmware_version'),
                'hardware_version': dtu_config.get('hardware_version'),
                'hostname': os.uname().nodename,
            },
            uid_prefix=_dtu_uid_prefix(),
        )
    except Exception as e:
        logger.error(f"导出备份失败: {e}")
        return jsonify({'success': False, 'message': str(e)}), 500
    if request.args.get('download') in ('1', 'true', 'True'):
        text = json.dumps(bundle, ensure_ascii=False, indent=2)
        fname = f"dzxj_dtu_backup_{dtu_config.get('dtu_id', 'dtu')}_{time.strftime('%Y%m%d_%H%M%S')}.json"
        resp = app.response_class(text, mimetype='application/json')
        resp.headers['Content-Disposition'] = f'attachment; filename="{fname}"'
        return resp
    return jsonify({'success': True, 'bundle': bundle})


@app.route('/api/backup/import', methods=['POST'])
def backup_import():
    """导入整机备份（支持上传文件/JSON body；dry_run=1 仅预览不应用）"""
    try:
        raw = b''
        if 'file' in request.files:
            raw = request.files['file'].read()
        dry_run = request.args.get('dry_run') in ('1', 'true', 'True')
        if not raw:
            body = request.get_json(silent=True)
            if isinstance(body, dict) and 'bundle' in body:
                raw = json.dumps(body['bundle'], ensure_ascii=False).encode('utf-8')
                dry_run = dry_run or bool(body.get('dry_run'))
            elif body is not None:
                raw = json.dumps(body, ensure_ascii=False).encode('utf-8')
            else:
                raw = request.get_data() or b''
        if not raw:
            return jsonify({'success': False, 'message': '未收到备份内容'}), 400
        if len(raw) > config_backup.MAX_BUNDLE_BYTES:
            return jsonify({'success': False, 'message': '备份文件过大'}), 400
        try:
            bundle = json.loads(raw.decode('utf-8'))
        except Exception:
            return jsonify({'success': False, 'message': '备份内容不是有效 JSON'}), 400
        ok, msg = config_backup.validate_bundle(bundle)
        if not ok:
            return jsonify({'success': False, 'message': msg}), 400
        preview = _backup_preview(bundle)
        if dry_run:
            return jsonify({'success': True, 'dry_run': True, 'preview': preview})
        logger.info(f"开始导入备份: created_at={bundle.get('created_at')} files={list((bundle.get('files') or {}).keys())}")
        summary = _apply_backup_bundle(bundle)
        logger.info(f"备份导入完成: {summary}")
        return jsonify({'success': True, 'message': '备份已恢复', 'preview': preview, **summary})
    except Exception as e:
        logger.error(f"导入备份失败: {e}")
        return jsonify({'success': False, 'message': str(e)}), 500


@app.route('/api/backup/list', methods=['GET'])
def backup_list():
    """列出设备内自动快照"""
    return jsonify({'success': True, 'backups': config_backup.list_snapshots(BACKUP_DIR)})


@app.route('/api/backup/download', methods=['GET'])
def backup_download():
    """下载指定快照文件"""
    name = request.args.get('name', '')
    data, err = config_backup.read_snapshot(name, BACKUP_DIR)
    if err:
        return jsonify({'success': False, 'message': err}), 404
    text = json.dumps(data, ensure_ascii=False, indent=2)
    resp = app.response_class(text, mimetype='application/json')
    resp.headers['Content-Disposition'] = f'attachment; filename="{os.path.basename(name)}"'
    return resp


@app.route('/api/backup/restore_snapshot', methods=['POST'])
def backup_restore_snapshot():
    """从设备内自动快照恢复单个配置文件"""
    try:
        payload = request.json or {}
        name = payload.get('name', '')
        content, err = config_backup.read_snapshot(name, BACKUP_DIR)
        if err:
            return jsonify({'success': False, 'message': err}), 404
        stem = config_backup.snapshot_stem(name)
        if not stem or stem not in _SNAPSHOT_TARGETS:
            return jsonify({'success': False, 'message': f'未知快照类型: {stem}'}), 400
        bundle = config_backup.build_bundle(
            {stem: content},
            device_meta={'source': 'snapshot', 'snapshot': name},
        )
        ok, msg = config_backup.validate_bundle(bundle)
        if not ok:
            return jsonify({'success': False, 'message': msg}), 400
        summary = _apply_backup_bundle(bundle)
        logger.info(f"已从快照 {name} 恢复: {summary}")
        return jsonify({'success': True, 'message': f'已从快照恢复 {stem}', **summary})
    except Exception as e:
        logger.error(f"快照恢复失败: {e}")
        return jsonify({'success': False, 'message': str(e)}), 500


@app.route('/api/backup/delete', methods=['POST'])
def backup_delete():
    """删除指定快照"""
    payload = request.json or {}
    ok, msg = config_backup.delete_snapshot(payload.get('name', ''), BACKUP_DIR)
    return (jsonify({'success': True, 'message': msg}) if ok
            else jsonify({'success': False, 'message': msg})), (200 if ok else 404)


@app.route('/api/system/restart_service', methods=['POST'])
def restart_service():
    """重启 dzxj_dtu 服务（延时 1 秒执行，让本次响应先返回）"""
    def _do_restart():
        import subprocess
        time.sleep(1.0)
        try:
            subprocess.run(['systemctl', 'restart', 'dzxj_dtu'], timeout=30)
            logger.info("已执行 systemctl restart dzxj_dtu")
        except Exception as e:
            logger.error(f"重启 dzxj_dtu 服务失败: {e}")
    threading.Thread(target=_do_restart, daemon=True).start()
    return jsonify({'success': True, 'message': 'dzxj_dtu 服务将在 1 秒后重启'})


if __name__ == '__main__':
    try:
        # 启动前的初始化工作
        logger.info('启动串口-MQTT网关服务...')
        logger.info(f"配置信息: 主机={FLASK_HOST}, 端口={FLASK_PORT}, 调试模式={FLASK_DEBUG}")

        # 加载DTU配置
        load_dtu_config()

        # 加载线架绑定表（地址↔UID）
        loaded = load_device_config()
        logger.info(f"已加载 {len(loaded)} 个线架绑定")

        # 自动连接上次使用的串口（RS485），必须先连接才能做地址段扫描
        logger.info("尝试自动连接串口...")
        auto_connect_serial()

        # 自动连接上次使用的MQTT服务器
        logger.info("尝试自动连接MQTT...")
        auto_connect_mqtt()

        # 根据绑定表重建面板列表（真实在线状态由地址段扫描实时刷新）
        try:
            _st = serial_client.get_status()
            if isinstance(_st, dict) and _st.get('connected', False) and dtu_config.get('enabled'):
                sync_panel_config()
            else:
                logger.info("串口未连接或 DTU 未启用，面板列表将在地址段扫描后建立")
        except Exception as e:
            logger.error(f"启动前检查串口状态失败: {e}")

        logger.info(f"当前面板数: {len(panel_config)}，地址段: {_address_range()[0]}-{_address_range()[1]}")

        # 启动DTU心跳定时器
        if dtu_config.get('enabled'):
            start_dtu_heartbeat()
            logger.info("启动DTU心跳定时器")

        # 启动线架地址段扫描循环（注册模型：地址段顺序轮询 + UID 绑定 + 换架自动接管）
        def port_poll_loop():
            while True:
                interval = dtu_config.get('poll_interval_ms', 5000) / 1000.0
                time.sleep(max(1, interval))
                try:
                    # 地址配置期间暂停扫描，避免总线上同时出现查询帧和配置帧
                    if not address_config.config_lock.acquire(blocking=False):
                        logger.info("地址配置进行中，本轮扫描跳过")
                        continue
                    try:
                        _st = serial_client.get_status()
                        if not (isinstance(_st, dict) and _st.get('connected', False)):
                            continue
                        if not dtu_config.get('enabled'):
                            continue
                        online, offline = _sweep_panel_addresses()
                        logger.debug(f"地址段扫描完成: 在线={online}, 离线/缺失={offline}")
                        dtu_publish_status(force=True)
                    finally:
                        address_config.config_lock.release()
                except Exception as e:
                    logger.error(f"线架地址段扫描异常: {str(e)}")
        t2 = threading.Thread(target=port_poll_loop, daemon=True)
        t2.start()
        logger.info(f"启动线架地址段扫描线程 (顺序轮询 {_address_range()[0]}-{_address_range()[1]})")

        # 启动 DHT11 本地传感器读取线程
        if dht11_sensor is not None:
            dht11_sensor.on_data = dht11_data_callback
            dht11_sensor.start()

        # 连接 Nextion 串口屏
        if NEXTION_ENABLED:
            try:
                ok, msg = screen_display.connect(NEXTION_SCREEN_PORT, NEXTION_SCREEN_BAUD)
                if ok:
                    screen_display.set_button_callback(screen_button_event_handler)
                    logger.info("Nextion 屏幕连接成功")
                    panels = get_sorted_panels()
                    if panels:
                        refresh_screen_panel(panels[0][0])
                    else:
                        # 没有配线架时也要把 IP/版本/MQTT 状态刷到屏幕
                        _send_screen_header()
                else:
                    logger.warning(f"Nextion 屏幕连接失败: {msg}")
            except Exception as e:
                logger.error(f"Nextion 屏幕初始化异常: {e}")

        # 启动 Nextion 屏幕异步刷新工作线程
        screen_refresh_thread = threading.Thread(target=_screen_refresh_worker, daemon=True)
        screen_refresh_thread.start()
        logger.info("启动 Nextion 屏幕异步刷新线程")

        # 启动网络 IP 监测线程：插网线获取到 IP 后及时写入串口屏
        network_ip_monitor_thread = threading.Thread(target=_network_ip_monitor_loop, daemon=True)
        network_ip_monitor_thread.start()
        logger.info("启动网络 IP 监测线程")

        # 启动服务
        socketio.run(
            app, 
            host=FLASK_HOST, 
            port=FLASK_PORT, 
            debug=FLASK_DEBUG,
            use_reloader=False,  # 禁用重载器以避免重复初始化问题
            log_output=False,  # 禁用Flask的日志输出，使用我们自己的日志配置
            allow_unsafe_werkzeug=True
        )
    except KeyboardInterrupt:
        # 优雅退出
        logger.info('正在关闭应用...')
        try:
            if isinstance(serial_client.get_status(), dict) and serial_client.get_status().get("connected", False):
                serial_client.disconnect()
                logger.info('串口连接已断开')
            if _mqtt_connected():
                mqtt_client.disconnect()
                logger.info('MQTT连接已断开')
            if dht11_sensor is not None:
                dht11_sensor.stop()
                logger.info('DHT11 传感器线程已停止')
        except Exception as e:
            logger.error(f'关闭连接时出错: {str(e)}')

        # 清理WebSocket连接
        for client_type in connected_clients:
            connected_clients[client_type].clear()
        
        logger.info('应用已安全关闭')
    except Exception as e:
        logger.exception(f'应用启动失败')  # 使用exception记录完整堆栈
        # 确保资源被释放
        try:
            serial_client.disconnect()
            mqtt_client.disconnect()
        except:
            pass