# core/serial_protocol.py
import serial
import serial.tools.list_ports
from utils.logger import logger

class SerialProtocol:
    def __init__(self):
        self.serial_port = serial.Serial()
        self.serial_port.BaudRate = 115200

    def select_all(self):
        """
        所有屏幕开机指令
        """
        # 根据你的协议文档，这里填入真实的十六进制指令
        # 示例: [Head, Cmd, Data...] -> bytes
        cmd_bytes = [
            0x80,  # HEAD (假设)
            0x74,  # CMD (拼接命令)
            0x1B,  # 起始位置
            0xFF, 0xFF, 0xFF, 0xFF  # 填充位 (根据协议长度补齐)
        ]
        return bytes(cmd_bytes)

    def cancel_all(self):
        """
        取消所有窗口选定
        """
        # 根据你的协议文档，这里填入真实的十六进制指令
        # 示例: [Head, Cmd, Data...] -> bytes
        cmd_bytes = [
            0x80,  # HEAD (假设)
            0x74,  # CMD (接命令)
            0x46,  # 起始位置
            0xFF, 0xFF, 0xFF, 0xFF  # 填充位 (根据协议长度补齐)
        ]
        return bytes(cmd_bytes)

    def power_on_all(self):
        """所有屏幕开机指令"""
        # 根据你的协议文档，这里填入真实的十六进制指令
        # 示例: [Head, Cmd, Data...] -> bytes
        cmd_bytes = [
            0x80,  # HEAD (假设)
            0x74,  # CMD (拼接命令)
            0x40,  # 起始位置
            0xFF, 0xFF, 0xFF, 0xFF  # 填充位 (根据协议长度补齐)
        ]
        return bytes(cmd_bytes)

    def power_off_panel(self, panel_id):
        """指定单屏关机"""
        # 假设协议是: 80 74 19 [PanelNo] FF FF FF FF
        # panel_id 是 1-12，转成16进制
        hex_panel = f"{panel_id:02X}"
        cmd_str = f"80 74 19 {hex_panel} FF FF FF FF"
        return bytes.fromhex(cmd_str)

    def switch_layout(self, start_pos, cols, rows, source_type=0x33):
        """切换拼接布局 (例如 2x2)"""
        # 示例指令，具体根据你的附件协议调整
        return bytes.fromhex(f"80 D6 10 {start_pos:02X} {rows:02X} {cols:02X} 01 FF")

    def create_mosaic_window(self, start_id, rows, cols, source_id):
        """
        生成拼接指令
        硬件协议通常是：设置逻辑屏大小 -> 绑定信号源 -> 显示
        """
        # 示例伪代码
        cmd1 = bytes.fromhex(f"80 D6 10 {start_id} {rows} {cols} {source_id} FF")
        return [cmd1]

    def calculate_mosaic_params(self, selected_widgets):
        """
        根据选中的屏幕控件，自动计算拼接参数
        策略：取最左上角和最右下角，生成一个完整的矩形
        """
        if not selected_widgets:
            return None

        # --- 第一步：找出边界 ---
        # 假设屏幕ID是 1-12，排列为 3行 x 4列
        # 我们需要根据ID计算坐标：行 = (ID-1) // 4, 列 = (ID-1) % 4

        print("根据选中的屏幕控件，自动计算拼接参数")

        positions = []
        ids = [w.screen_id for w in selected_widgets]  # 获取选中控件的ID列表

        for screen_id in ids:
            row = (screen_id - 1) // 4
            col = (screen_id - 1) % 4
            positions.append((row, col))

        # --- 第二步：计算包围矩形 ---
        if not positions:
            # 处理无选中控件的情况，防止后续 min/max 报错
            min_row = max_row = min_col = max_col = 0
        else:
            # 正确提取行号和列号
            rows = [pos[0] for pos in positions]
            cols = [pos[1] for pos in positions]

            min_row, max_row = min(rows), max(rows)
            min_col, max_col = min(cols), max(cols)

        # --- 第三步：生成参数 ---
        start_id = min_row * 4 + min_col + 1  # 转回物理ID
        start_param = start_id - 1  # 协议参数：PanelNumber - 1

        # h_count (水平个数), Vcount (垂直个数)
        h_count = max_col - min_col + 1
        v_count = max_row - min_row + 1

        # --- 第四步：逻辑校验 ---
        # 检查这个矩形区域内是否有未被选中的屏幕（缺角情况）
        missing_screens = []
        for r in range(min_row, max_row + 1):
            for c in range(min_col, max_col + 1):
                expected_id = r * 4 + c + 1
                if expected_id not in ids:
                    missing_screens.append(expected_id)

        return {
            "start": start_param,
            "h_count": h_count,
            "v_count": v_count,
            "missing_screens": missing_screens, # 用于提示用户
            "min_row": min_row,
            "min_col": min_col
        }

    def build_mosaic_packet(self, start, h_count, v_count, big_pic_id, cmd_type=0x10):
        """
        封装拼接指令包
        :param start: 起始物理屏编号 (int)
        :param h_count: 水平数量 (int)
        :param v_count: 垂直数量 (int)
        :param big_pic_id: 拼接大画面序列号，默认0x01表示拼接id (int)
        :param cmd_type: 命令字，默认0x01表示拼接 (int)
        :return: bytes (指令字节流)，失败则抛出ValueError
        """
        # 参数类型检查
        if not all(isinstance(i, int) for i in [start, h_count, v_count, big_pic_id, cmd_type]):
            raise ValueError("所有参数必须为整数")

        try:
            # 限制数值范围，防止溢出
            start = max(0, min(255, start))  # 屏幕编号范围 0~255
            h_count = max(1, min(16, h_count))  # 最大横向16块屏幕
            v_count = max(1, min(16, v_count))  # 最大纵向16块屏幕

            # 协议格式: [帧头][命令][起始地址][横向数][纵向数][帧尾]
            frame_head_1 = 0x80  # 帧头1
            frame_head_2 = 0xD6  # 帧头2
            frame_tail = 0xFF  # 帧尾

            # 构造数据包列表
            packet = [
                frame_head_1,
                frame_head_2,
                cmd_type,
                start,
                v_count,
                h_count,
                big_pic_id,
                frame_tail
            ]

            # 返回构造完成的数据包
            return bytes(packet)

        except Exception as e:
            print(f"协议封装错误: {e}")
            raise ValueError("构建拼接指令包失败") from e