import chardet


class Gtake(object):
    # 初始化一个空列表，用来存分割好的寄存器信息
    def __init__(self):
        self.real_adr_dict = {  # 变频器参数组的字典
            "A0": 0x00, "A1": 0x01,
            "a0": 0x00, "a1": 0x01,
            "b0": 0x02, "b1": 0x03, "b2": 0x04,
            "B0": 0x02, "B1": 0x03, "B2": 0x04,
            "C0": 0x05, "C1": 0x06, "C2": 0x07, "C3": 0x08, "C4": 0x09,
            "c0": 0x05, "c1": 0x06, "c2": 0x07, "c3": 0x08, "c4": 0x09,
            "d0": 0x0A, "d1": 0x0B, "d2": 0x0C, "d3": 0x0D, "d4": 0x0E, "d5": 0x0F, "d6": 0x10,
            "D0": 0x0A, "D1": 0x0B, "D2": 0x0C, "D3": 0x0D, "D4": 0x0E, "D5": 0x0F, "D6": 0x10,
            "E0": 0x11, "E1": 0x12,
            "e0": 0x11, "e1": 0x12,
            "F0": 0x13, "F1": 0x14, "F2": 0x15, "F3": 0x16, "F4": 0x17, "F5": 0x18, "F6": 0x19,
            "f0": 0x13, "f1": 0x14, "f2": 0x15, "f3": 0x16, "f4": 0x17, "f5": 0x18, "f6": 0x19,
            "H0": 0x1A, "H1": 0x1B, "H2": 0x1C,
            "h0": 0x1A, "h1": 0x1B, "h2": 0x1C,
            "L0": 0x1D, "L1": 0x1E,
            "l0": 0x1D, "l1": 0x1E,
            "U0": 0x1F, "U1": 0x20, "U2": 0x21,
            "u0": 0x1F, "u1": 0x20, "u2": 0x21,
        }
        self.list1 = []  # 从txt文件循环读取，去除空行后，一行转换一个值，存到这个列表
        self.list2 = []  # 这个列表存储去除空格、tab键、\n，后，再次放入列表
        self.list3 = []  # 这个列表用来存储首次分割开的参数表:这个是嵌套列表结构
        self.list4 = []  # 这个列表是在list3列表的基础上，插入真实的地址到[0]

    # 编码方式读取
    @staticmethod
    def get_encoding(txt_path):
        with open(txt_path, 'rb') as f:
            return chardet.detect(f.read())['encoding']

    # step1.读取txt文件
    def read_txt(self, txt_path):
        # 编码方式读取
        encod = self.get_encoding(txt_path)
        # 打开txt文件，遍历
        with open(txt_path, "r", encoding=encod) as f:
            for x in f.readlines():
                if x != "\n":
                    self.list1.append(x)

    # step2.一条参数一条参数的处理，去掉空格、tab键、换行\n后，转换成一个新的嵌套的列表
    def list1_2_list2(self):
        if self.list1:
            for str1 in self.list1:
                # 去掉空格
                str2 = str1.replace("\t", "")  # A0-03 = 3     # 恢复出厂以后，开始调整以下参数
                # 去掉tab键
                str3 = str2.replace(" ", "")  # A0-03=3#恢复出厂以后，开始调整以下参数
                # 去掉结尾的 \n
                str4 = str3.replace("\n", "")  # A0-03=3#恢复出厂以后，开始调整以下参数
                self.list2.append(str4)
        else:
            print("step2提示：step1从txt中转换出来的列表应该是空的，step2不用执行！")

    # step3.对列表中的每一条，都进行分割：['A0', '03', '03', '恢复出厂以后，开始调整以下参数']
    def list2_2_list3(self):
        if self.list2:
            for str1 in self.list2:  # A0-03=3#恢复出厂以后，开始调整以下参数
                # 先切割#或//
                index1 = str1.find("-")
                index2 = str1.find("=")
                index3 = str1.find("#")
                index4 = str1.find("//")
                # 按下标切割，并添加加列表
                list3_temp = []
                # 先把字符串从#或//,切割成2段
                if index3 != -1:
                    str4_part1 = str1[:index3]
                    str4_part2 = str1[index3 + 1:]
                elif index4 != -1:
                    str4_part1 = str1[:index4]
                    str4_part2 = str1[index4 + 2:]
                else:
                    str4_part1 = str1
                    str4_part2 = ""
                # 如果前半部分不为空，则说明是完整的参数，否则说明只是注释。
                if str4_part1 != "":
                    str5_part1 = str1[:index1]
                    str5_part2 = str1[index1 + 1:index2]

                    # 对于 # 或 // 要分情况讨论
                    if index3 != -1:  # 如果有注释的话
                        str5_part3 = str1[index2 + 1:index3]
                    elif index4 != -1:
                        str5_part3 = str1[index2 + 1:index4]
                    else: # 如果都是 -1 说明是没有注释
                        str5_part3 = str1[index2 + 1:]
                    list3_temp.append(str5_part1)
                    list3_temp.append(str5_part2)
                    list3_temp.append(str5_part3)
                    list3_temp.append(str4_part2)
                else:
                    # 这个是只有注释的情况
                    list3_temp.append("")
                    list3_temp.append("")
                    list3_temp.append(str4_part2)

                # 执行一次后，小列表插入到大列表中
                self.list3.append(list3_temp)

        else:
            # 找印一下：list2 是空列表
            print("list2 是空列表，step3不用执行！")

    # step4.查找字典，找出真实的寄存器地址，再次的修改列表成list4.
    def list3_2_list4(self):
        if self.list3:
            for x in self.list3:
                if x[0] != "":
                    # 不为空，则查询并计算
                    aa = self.real_adr_dict[x[0]] * 0x100 + int(x[1])
                    # 再次做出一个列表
                    list4_temp = []
                    list4_temp.append(aa)
                    list4_temp.append(int(x[2]))
                    # 列表后面的组合在一起，如果有注释，则连接上
                    if len(x) > 3:
                        str4_temp = "{0}-{1}={2}       {3}".format(x[0], x[1], x[2], x[3])
                        list4_temp.append(str4_temp)
                    else:
                        str4_temp = "{0}-{1}={2}".format(x[0], x[1], x[2])

                    # 以上处理完成后，临时列表加入总列表
                    self.list4.append(list4_temp)
                else:
                    # 为空说明这条参数是注释，直接添加加到列表
                    self.list4.append(x)

        else:
            # 找印一下：list3 是空列表
            print("list3 是空列表，step4不用执行！")

    # 总的调用
    def read_txt_2_list(self, txt_adr):
        self.read_txt(txt_adr)
        self.list1_2_list2()
        self.list2_2_list3()
        self.list3_2_list4()
        print("读取、转换完成！")


if __name__ == "__main__":
    gtake = Gtake()
    # # step1.读取txt文件，返回一个分割好的列表list1:去掉空行
    # gtake.read_txt("变频器参数表.txt")
    # # 显示打印一下，看看效果：如果是空就不再显示。
    # if gtake.list1:
    #     print("*" * 50)
    #     print("step1.读取txt,已全部转换成列表，列表如下：")
    #     for y in gtake.list1:
    #         print(y)
    # else:
    #     print("step1.读取txt,没有发现要修改的参数，生成的列表是空的")
    #
    # # step2.列表去掉空格、tab键、换行符
    # gtake.list1_2_list2()
    # # 打印一下，看看list2
    # if gtake.list2:
    #     print("*" * 50)
    #     print("step2.list1-->list2,已全部转换成完成，列表如下：")
    #     for x in gtake.list2:
    #         print(x)
    #
    # # step3.分割每一条参数，转换成列表
    # gtake.list2_2_list3()
    # # 打印一下，看看list3
    # if gtake.list3:
    #     print("*" * 50)
    #     print("step3.list2-->list3,已全部转换成完成，列表如下：")
    #     for x in gtake.list3:
    #         print(x)

    # # step4.查字典计算真实地址，重整列表
    # gtake.list3_2_list4()
    # # 打印一下，看看list4
    # if gtake.list4:
    #     print("*" * 50)
    #     print("step4.list3-->list4,已全部转换成完成，列表如下：")
    #     for x in gtake.list4:
    #         print(x)
    # else:
    #     print("list4是空列表")

    # 总的调用测试
    # gtake.read_txt_2_list("变频器参数表.txt")
    gtake.read_txt_2_list("test.txt")
    # 结果打印一下
    for x in gtake.list4:
        print(x)