import struct
from crc import Calculator, Crc16

from .. import tools

modbus_map = {
    # 1 - Hex
    # 2 - Int16
    # 3 - lnt32
    # 4 - str
    # 5 - addr
    # 6 - float
    # 7 - numberList
    0x01: ["Hex示例",   1],
    0x02: ["Int示例",   2],
    0x03: ["Int32示例", 3],
    0x05: ["str示例",   4, 16],
    0x15: ["addr示例",  5,  6],
    0x1B: ["Float示例", 6],
    0x1D: ["numberList示例", 3],
    0x20: ["callback示例", 16],
}

frame_modbus = {
    # func: len_base, type, idx
        # type = 0, fixed length
        # type = 1, add uint8 length by idx
        # type = 2, add uint16 length by idx
        # type = 3, check sub func code by idx, choose fixed length
    0x03: [5, 1, 2],
    0x04: [5, 1, 2],
    0x06: [8, 0],
    0x07: [8, 3, 2, {0x01: 2, 0x02: 0, 0x03: 0}],
    0x08: [5, 3, 2, {0x01: 1, 0x02: 0x22, 0x03: 1}],
    0x10: [8, 0],
    0x11: [11, 2, 7]
}


def make_frame_modbus(block:dict) -> bytearray:
    """ modbus 生成函数"""
    frame = []
    calculator = Calculator(Crc16.MODBUS)

    frame.append(block['addr_dev'])
    if block['type'] == 'update':
        """ 升级系列报文 """
        frame.append(0x07)
        if len(block['file']) <= block["header_offset"]:
            raise Exception("Modbus Update error, file too small.")
        
        if block['step'] == 'start':
            frame.append(0x01)
            frame.append(0x00)
            frame.append(0x00)
            frame.append(0x00)
            frame.append(block['header_offset'] // 256)
            frame.append(block['header_offset'] % 256)
            frame += list(block['file'][:block['header_offset']])
        elif block['step'] == 'trans':
            file_offset = block["header_offset"] + block['index'] * block['file_block_size']
            file_block = block['file'][file_offset: file_offset + block['file_block_size']]
            frame.append(0x02)
            frame.append(0x00)
            frame.append(block['index'] // 256)
            frame.append(block['index'] % 256)
            frame.append(len(file_block) // 256)
            frame.append(len(file_block) % 256)
            frame += list(file_block)
        elif block['step'] == 'end':
            frame.append(0x03)
            frame.append(0x00)
            frame.append(block['index'] // 256)
            frame.append(block['index'] % 256)
            frame.append(0x00)
            frame.append(0x00)
        else:
            raise Exception("Modbus Update Frame Step Error.")
    elif block['type'][:6] == 'record':
        """ 录波系列报文 """
        frame.append(0x11)
        if block['type'][7:10] == 'cfg':
            frame.append(0x01)
        elif block['type'][7:11] == 'data':
            frame.append(0x02)
        else:
            raise Exception("Modbus Record Frame Type Error.")

        if block['step'] == 'start':
            frame.append(0x00)
        elif block['step'] == 'next':
            frame.append(0x01)
        elif block['step'] == 'repeat':
            frame.append(0x02)
        else:
            raise Exception("Modbus Record Frame Step Error.")
        
        frame.append(block['file_block_size'] // 256)
        frame.append(block['file_block_size'] % 256)
    elif block['type'] == 'log':
        """ 事件记录系列报文 """
        frame.append(0x08)
        if block['step'] == 'start':
            frame.append(0x01)
            frame.append(block['data_len'] // 0x100 % 0x100)
            frame.append(block['data_len'] % 0x100)
        elif block['step'] == 'next':
            frame.append(0x02)
        elif block['step'] == 'end':
            frame.append(0x03)
        else:
            raise Exception("Modbus Log Frame Step Error.")
    else:
        """ 数据读取系列报文 """
        data_addr = block['data_addr']
        if block['type'] == "read":
            frame.append(0x03)
            data_len  = block['data_len']
            frame.append(data_addr // 256 % 256)
            frame.append(data_addr % 256)
            frame.append(data_len // 256 % 256)
            frame.append(data_len % 256)
        elif block['type'] == "write_one":
            frame.append(0x06)
            data_val  = block['data_val']
            if data_val < 0:
                data_val += 0x1_0000
            frame.append(data_addr // 256 % 256)
            frame.append(data_addr % 256)
            frame.append(data_val // 256 % 256)
            frame.append(data_val % 256)
        elif block['type'] == "write_dual":
            frame.append(0x10)
            data_val  = block['data_val']
            if data_val < 0:
                data_val += 0x1_0000_0000
            frame.append(data_addr // 256 % 256)
            frame.append(data_addr % 256)
            frame.append(0x00)
            frame.append(0x02)
            frame.append(0x04)
            frame.append(data_val // 256 % 256)
            frame.append(data_val % 256)
            data_val //= 0x1_0000
            frame.append(data_val // 256 % 256)
            frame.append(data_val % 256)
        elif block['type'] == "write_str":
            frame.append(0x10)
            data_len = len(block['data_val'])
            item_len = 2 * block['data_define'][data_addr][2] if data_addr in block['data_define'].keys() else data_len
            data_val  = block['data_val']
            if data_len > item_len:
                raise Exception("Modbus data len oversize.")
            elif data_len < item_len:
                data_val += b'\000' * (item_len - data_len)
                data_len  = len(data_val)
            frame.append(data_addr // 256 % 256)
            frame.append(data_addr % 256)
            frame.append(0x00)
            frame.append(data_len // 2)
            frame.append(data_len)

            if type(data_val[0]) == str:
                data_val = list(map(lambda x: x.encode()[0], data_val))
            for i in range(data_len//2):
                frame.append(data_val[2*i + 1])
                frame.append(data_val[2*i])
        else:
            raise Exception("Modbus Frame Type Error.")

    crc = calculator.checksum(bytearray(frame))
    frame.append(crc % 256)
    frame.append(crc // 256)

    return bytearray(frame)


def make_frame_dlt645(block:dict) -> bytearray:
    """ dlt645 生成函数"""
    frame = []

    if block['type'] == 'modbus':
        """ Modbus 透传帧 """
        ctrl_code = 0x1F    # Modbus 透传帧功能码
        data_frame = make_frame_modbus(block["data"])
        len_data = len(data_frame)
    else:
        raise Exception("Unknown dlt645 frame type.")

    frame.append(0x68)
    frame += block['addr'][:6]
    frame.append(0x68)
    frame.append(ctrl_code)
    frame.append(len_data)
    frame += data_frame
    frame.append(sum(frame) % 256)
    frame.append(0x16)

    return bytearray(frame)


def check_frame_modbus(frame:bytes, block:dict) -> dict:
    """ 校验modbus帧回复 """
    if len(frame:=find_frame_modbus(frame, block['addr_dev'])) == 0:
        raise Exception("No frame data")
    
    output = {
        'result': False,
        'code_func': frame[1],
        'code_sub': frame[2],
    }
    if output['code_func'] == 0x07:
        """ 升级回复帧 """
        output['upgrade'] = {}
        output['upgrade']['index'] = frame[4] * 256 + frame[5]
        if output['code_sub'] == 0x01:
            """ 升级开始, 处理文件头 """
            output['upgrade']['length'] = frame[6] * 256 + frame[7]
        elif output['code_sub'] == 0x02:
            """ 升级传输, 解析帧序号及返回值, 不做序列号校验 """
            pass
        elif output['code_sub'] == 0x03:
            """ 升级结束 """
            pass
        else:
            raise Exception(" Upgrade SubFunc code error.")
        output['result'] = True if frame[3] == 0x00 else False
        output['code_error'] = frame[3]
    elif output['code_func'] == 0x03 or output['code_func'] == 0x04:
        """ 数据读取帧 """
        if frame[2] == len(frame[3:-2]):
            output['Regs'] = display_data(block['data_addr'], frame[3:-2], block['data_define'])
        else:
            raise Exception("Frame read data length error.")
        output['result'] = True
    elif output['code_func'] == 0x08:
        if frame[2] == 0x02:
            output['Regs'] = display_data(0x200, frame[5:-2], block['data_define'])
        else:
            raise Exception(" Log SubFunc code error.")
        output['result'] = True
    elif output['code_func'] == 0x06:
        """ 单个数据写入帧 """
        output['result'] = True
    elif output['code_func'] == 0x10:
        """ 多个数据写入帧 """
        output['result'] = True
    elif output['code_func'] == 0x11:
        """ 录波功能帧 """
        data_record = {}
        if frame[2] == 0x01:
            data_record['type'] = 'config'
        elif frame[2] == 0x02:
            data_record["type"] = 'data'
        else:
            raise Exception("Unknow data type")
        data_record['seq']   = frame[5] * 0x100 + frame[6]
        data_record['total'] = frame[3] * 0x100 + frame[4]
        data_record['data']  = frame[9:-2]
        output['record'] = data_record
        output['result'] = True
    elif output['code_func'] & 0x80:
        """ 错误返回帧 """
        output['code_error'] = frame[2] if output['code_func'] == 0x87 else frame[3]
    else:
        raise Exception(f"Frame Date error. func={output['code_func']}, func_sub={output['code_sub']}, len={len(frame)}")

    return output


def check_frame_dlt645(frame:bytes, block:dict) -> dict:
    """ 校验dlt645帧回复 """
    if len(frame:=find_frame_dlt645(frame, block['addr'])) == 0:
        raise Exception("No frame data")
    
    code_func = frame[8]
    if code_func == 0x9F:
        return check_frame_modbus(frame[10:-2], block['data'])
    else:
        raise Exception("DLT645 Frame type error.")


def find_frame_modbus(buffer:bytes, address:int, frame_defines: dict=frame_modbus) -> bytes:
    """ 搜索合法modbus帧子串 """
    len_buffer = len(buffer)

    pos_frame, len_frame = 0, 0
    calculator = Calculator(Crc16.MODBUS)
    for i in range(len_buffer):
        if buffer[i] != address:
            continue
        if (buffer[i+1] & 0x7F) not in frame_defines.keys():
            continue
        
        frame_define = frame_defines[buffer[i+1] & 0x7F]
        j = frame_define[0]
        if buffer[i+1] & 0x80:
            j = 5
        elif frame_define[1] == 0:
            pass
        elif frame_define[1] == 1:
            j += buffer[i+frame_define[2]]
        elif frame_define[1] == 2:
            j += buffer[i+frame_define[2]] * 0x100 + buffer[i+frame_define[2]+1]
        elif frame_define[1] == 3:
            if buffer[i+frame_define[2]] not in frame_define[3].keys():
                continue
            j += frame_define[3][buffer[i+frame_define[2]]]
        else:
            raise Exception("Unknow Modbus Define type.")

        if ((i+j) <= len_buffer) and calculator.checksum(buffer[i:i+j-2]) == (buffer[i+j-1] * 0x100 + buffer[i+j-2]):
            pos_frame, len_frame = i, j
            break
    
    return buffer[pos_frame: pos_frame+len_frame]


def find_frame_dlt645(buffer:bytes, address: list) -> bytes:
    """ 搜索合法645帧子串 """
    len_buffer = len(buffer)

    pos_frame, len_frame = 0, 0
    for i in range(len_buffer):
        if buffer[i] != 0x68 or buffer[i+7] != 0x68:
            continue
        if address[0] != 0xAA and buffer[i+1:i+7] != bytes(address):
            continue

        j = buffer[i+9] + 12
        if sum(buffer[i:i+j-2]) % 0x100 == buffer[i+j-2]:
            pos_frame, len_frame = i, j
            break
    
    return buffer[pos_frame: pos_frame+len_frame]


def display_data(address: int, data: bytes, modbus_map: dict=modbus_map) -> dict:
    """ 格式化表示数据, 得到显示数据字典 """
    def swapping_words(data:bytes, length:int) -> bytearray:
        item = bytearray(data[:2 * length])
        for i in range(length):
            item[2*i], item[2*i+1] = item[2*i+1], item[2*i]
        return item
    def convert_regs_to_int(data:bytes, length:int, signed: bool=True) -> int:
        result = 0
        for idx_data, byte_data in enumerate(swapping_words(data, length)):
            result += byte_data * 2 ** (8 * idx_data)
        result -= 2 ** (16 * length) if signed and result >= (2 ** (16 * length - 1)) else 0
        return result

    output_data = {}
    idx = address
    while data:
        data_label, data_len = "未知数据", 1
        if idx not in modbus_map.keys():
            item = convert_regs_to_int(data, 1, signed=False)
            item = tools.ByteConv.display_hex(item, 4)
        else:
            current_map = modbus_map[idx]
            data_label = current_map[0]
            if current_map[1] == 1:
                """ Hex字符表示 """
                item = convert_regs_to_int(data, 1, signed=False)
                item = tools.ByteConv.display_hex(item, 4)
            elif current_map[1] == 2:
                """ 16位数值表示 """
                item = convert_regs_to_int(data, 1)
                if len(current_map) > 2:
                    item /= current_map[2]
            elif current_map[1] == 3:
                """ 32位数值表示 """
                data_len = 2
                item = convert_regs_to_int(data, 2)
                if len(current_map) > 2:
                    item /= current_map[2]
            elif current_map[1] == 4:
                """ 字符串表示 """
                data_len = current_map[2]
                item = swapping_words(data, data_len)
                try:
                    item = item.decode()
                except Exception as ex:
                    item_len = sum([any(item[i:]) for i in range(len(item))])
                    item = tools.ByteConv.trans_list_to_str(item[:item_len])
            elif current_map[1] == 5:
                """ 载波地址表示 """
                data_len = current_map[2]
                item = swapping_words(data, data_len)
                item = tools.ByteConv.trans_list_to_str(item)
            elif current_map[1] == 6:
                """ 浮点数值表示 """
                data_len = 2
                item = struct.unpack('>f', bytes([data[2], data[3], data[0], data[1]]))[0]
            elif current_map[1] == 7:
                """ 正序数值表示 """
                data_len = current_map[2]
                item = list(map(lambda x: x, data[:2 * data_len]))
            elif current_map[1] == 8:
                """ 事件记录解析 """
                data_len = current_map[2]
                time_stamp, event_id, event_num = struct.unpack('<IBB', data[:6])
                item = f"Event: {event_id}\n"
                item += f"\ttime: {time_stamp}\n"
                item += f"\tnumber: {event_num}\n"
                if event_id == 2:
                    """ 故障记录事件 """
                    info_len, status, flag_fault, flag_alarm, volt_in, volt_out, curr_in, curr_induc, cbox_power_limit, flag_control = struct.unpack('<BBHHhhhhhH', data[6:6+18])
                    info = data[6+18:6+18+info_len].decode().strip('\x00')
                    item += f"\tData: {info}\n"
                    item += f"\t\tstatus:           {status:x}\n"
                    item += f"\t\tflag_fault:       {flag_fault:x}\n"
                    item += f"\t\tflag_alarm:       {flag_alarm:x}\n"
                    item += f"\t\tvolt_in:          {volt_in / 10}\n"
                    item += f"\t\tvolt_out:         {volt_out / 10}\n"
                    item += f"\t\tcurr_in:          {curr_in / 100}\n"
                    item += f"\t\tcurr_induc:       {curr_induc / 100}\n"
                    item += f"\t\tcbox_power_limit: {cbox_power_limit / 10}\n"
                    item += f"\t\tflag_control:     {flag_control:b}\n"
                else:
                    info_len, = struct.unpack('<B', data[6:6+1])
                    info = data[7:7+info_len].decode().strip('\x00')
                    item += f"\tData: {info}\n"


        output_data[idx] = data_label, item
        idx += data_len
        data = data[2*data_len:]
    return output_data


def print_display(output_data: dict):
    """ 格式化表示输出数据 """
    bank_chars = ' \t\000'
    print("Parse Result:")
    label_len_max = max(map(lambda x: len(x[0]), output_data.values()))
    data_len_max = max(map(lambda x: len(str(x[1])), output_data.values()))
    for key, value in output_data.items():
        match value:
            case (str() as label, list() as data):
                print(f"{tools.ByteConv.display_hex(key, 4)}: {'-'.join(map(str, data)):<{data_len_max}} {label:<{label_len_max}}")
            case (str() as label, str() as data):
                print(f"{tools.ByteConv.display_hex(key, 4)}: {data.rstrip(bank_chars):<{data_len_max}} {label:<{label_len_max}}")
            case (str() as label, data):
                print(f"{tools.ByteConv.display_hex(key, 4)}: {data:<{data_len_max}} {label:<{label_len_max}}")
            case _:
                raise ValueError(f"Key: {key}, Unkown Value: {value}")