import argparse
import struct
import time
import xml.etree.ElementTree as ET

import serial


SOF = b"\xAA\x55"
EOF = b"\x0D"

CMD_HANDSHAKE = 0x01
CMD_SET_ROLE = 0x02
CMD_READ_REGISTER = 0x10
CMD_WRITE_REGISTER = 0x11
CMD_READ_GROUP = 0x20
CMD_WRITE_GROUP = 0x21
CMD_READ_PACKAGE = 0x30
CMD_DATA_CHUNK = 0x31
CMD_READ_XML = 0x32
CMD_ACK = 0x7E
CMD_ERROR = 0x7F

XML_DATA_STRUCTURE_ID = 0xFFFF


def checksum16(data: bytes) -> int:
    return sum(data) & 0xFFFF


def build_frame(cmd: int, payload: bytes = b"") -> bytes:
    body = bytes([cmd]) + payload
    length = struct.pack("<H", len(body))
    cs = struct.pack("<H", checksum16(length + body))
    return SOF + length + body + cs + EOF


class FrameParser:
    def __init__(self):
        self.buf = bytearray()

    def feed(self, data: bytes):
        self.buf.extend(data)
        frames = []

        while True:
            sof_index = self.buf.find(SOF)
            if sof_index < 0:
                self.buf.clear()
                break

            if sof_index > 0:
                del self.buf[:sof_index]

            if len(self.buf) < 2 + 2:
                break

            length = struct.unpack("<H", self.buf[2:4])[0]
            total = 2 + 2 + length + 2 + 1

            if len(self.buf) < total:
                break

            raw = bytes(self.buf[:total])
            del self.buf[:total]

            if raw[-1:] != EOF:
                continue

            body = raw[4:4 + length]
            recv_cs = struct.unpack("<H", raw[4 + length:4 + length + 2])[0]
            calc_cs = checksum16(raw[2:4] + body)

            if recv_cs != calc_cs or not body:
                continue

            cmd = body[0]
            payload = body[1:]
            frames.append((cmd, payload))

        return frames


def strip_namespace(tag: str) -> str:
    if "}" in tag:
        return tag.split("}", 1)[1]
    return tag


def parse_register_defaults(xml_bytes: bytes):
    result = {}

    try:
        root = ET.fromstring(xml_bytes)
    except Exception:
        return result

    for elem in root.iter():
        if strip_namespace(elem.tag) != "register":
            continue

        reg_id = elem.attrib.get("id")
        reg_type = elem.attrib.get("type", "uint32")

        if not reg_id:
            continue

        default_value = "0"
        for child in list(elem):
            if strip_namespace(child.tag) == "value":
                default_value = child.attrib.get("default", "0")
                break

        result[int(reg_id)] = (reg_type, default_value)

    return result


def encode_value(reg_type: str, text: str) -> bytes:
    try:
        if reg_type in ("uint8", "byte"):
            return struct.pack("<B", int(text, 0))
        if reg_type in ("uint16", "usint"):
            return struct.pack("<H", int(text, 0))
        if reg_type == "uint32":
            return struct.pack("<I", int(text, 0))
        if reg_type == "int32":
            return struct.pack("<i", int(text, 0))
        if reg_type == "uint64":
            return struct.pack("<Q", int(text, 0))
        if reg_type == "float32":
            return struct.pack("<f", float(text))
        if reg_type == "string":
            return text.encode("utf-8")
    except Exception:
        pass

    return struct.pack("<I", 0)


def send_ack(ser, ack_cmd: int, status: int = 0, detail: int = 0):
    payload = struct.pack("<BBH", ack_cmd, status, detail)
    ser.write(build_frame(CMD_ACK, payload))


def send_error(ser, failed_cmd: int, err: int, detail: int = 0):
    payload = struct.pack("<BHH", failed_cmd, err, detail)
    ser.write(build_frame(CMD_ERROR, payload))


def send_xml(ser, xml_bytes: bytes, chunk_size: int = 128):
    transfer_id = 1

    # READ_XML 元信息：
    # transportVersion, encoding, compression, flags,
    # payloadSize, xmlSize, checksum, transferId, reserved
    #
    # 这里 compression=0，表示不压缩，方便上位机直接解析。
    transport_version = 1
    encoding = 1
    compression = 0
    flags = 0x01
    payload_size = len(xml_bytes)
    xml_size = len(xml_bytes)
    checksum = 0

    meta = struct.pack(
        "<BBBBIIIH",
        transport_version,
        encoding,
        compression,
        flags,
        payload_size,
        xml_size,
        checksum,
        transfer_id,
    )

    # 补到 20 字节，适配上位机当前解析逻辑
    meta += b"\x00" * (20 - len(meta))

    ser.write(build_frame(CMD_READ_XML, meta))
    time.sleep(0.03)

    offset = 0
    while offset < len(xml_bytes):
        chunk = xml_bytes[offset:offset + chunk_size]

        payload = struct.pack(
            "<HHIIH",
            transfer_id,
            XML_DATA_STRUCTURE_ID,
            len(xml_bytes),
            offset,
            len(chunk),
        ) + chunk

        ser.write(build_frame(CMD_DATA_CHUNK, payload))
        offset += len(chunk)
        time.sleep(0.01)


def send_register_value(ser, reg_id: int, raw: bytes):
    payload = struct.pack("<HH", reg_id, len(raw)) + raw
    ser.write(build_frame(CMD_READ_REGISTER, payload))


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--port", default="COM11")
    parser.add_argument("--baud", type=int, default=115200)
    parser.add_argument("--xml", default="COMDefine.xml")
    args = parser.parse_args()

    with open(args.xml, "rb") as f:
        xml_bytes = f.read()

    register_defaults = parse_register_defaults(xml_bytes)
    
    register_values = {}

for reg_id, (reg_type, default_text) in register_defaults.items():
    register_values[reg_id] = encode_value(reg_type, default_text)

    ser = serial.Serial(args.port, args.baud, timeout=0.05)
    parser_state = FrameParser()

    print(f"Device simulator opened {args.port}, baud={args.baud}")
    print("Waiting host frames...")

    while True:
        data = ser.read(4096)
        if not data:
            continue

        for cmd, payload in parser_state.feed(data):
            print(f"RX cmd=0x{cmd:02X}, payload={len(payload)}")

            if cmd == CMD_HANDSHAKE:
                # major=1, minor=0, capabilityFlags=0
                ser.write(build_frame(CMD_HANDSHAKE, struct.pack("<BBH", 1, 0, 0)))

            elif cmd == CMD_SET_ROLE:
                send_ack(ser, CMD_SET_ROLE, 0, 0)

            elif cmd == CMD_READ_XML:
                send_xml(ser, xml_bytes)

            elif cmd == CMD_READ_REGISTER:
                if len(payload) < 2:
                    send_error(ser, cmd, 0x0002)
                    continue
            
                reg_id = struct.unpack("<H", payload[:2])[0]
            
                if reg_id not in register_values:
                    reg_type, default_text = register_defaults.get(reg_id, ("uint32", "0"))
                    register_values[reg_id] = encode_value(reg_type, default_text)
            
                raw = register_values[reg_id]
                print(f"READ_REGISTER id={reg_id}, raw={raw.hex(' ')}")
                send_register_value(ser, reg_id, raw)

                elif cmd == CMD_WRITE_REGISTER:
                    if len(payload) < 4:
                        send_error(ser, cmd, 0x0002)
                        continue
                
                    reg_id = struct.unpack("<H", payload[:2])[0]
                    value_len = struct.unpack("<H", payload[2:4])[0]
                    value = payload[4:4 + value_len]
                
                    if len(value) != value_len:
                        send_error(ser, cmd, 0x0002)
                        continue
                
                    register_values[reg_id] = value
                
                    print(f"WRITE_REGISTER id={reg_id}, raw={value.hex(' ')}")
                    send_ack(ser, CMD_WRITE_REGISTER, 0, reg_id)

            else:
                send_error(ser, cmd, 0x0005)


if __name__ == "__main__":
    main()