import modbus_tk.defines as cst
from modbus_tk import modbus_tcp, hooks, modbus
import menu_utils as utils
import menu_key_def as KEYDEF
import ZZ_9TE as device_9TE
import struct
from threading import Thread
from typing import Tuple
from device_conf import class_comm_device_config
from comm_device import class_comm_device
from menu_base import class_menu_layer_info, class_device_menu
import menu_page
import modbus_server
from modbus_server import class_modbus_tcp_server
import comm_global
from comm_thread import class_comm_master_thread

DEFAULT_EMPTY_STR            = " "
MAX_NUMS_OF_STRING           = 20   #每个字符串占用寄存器数
MAX_NUMS_OF_MENU_LINE        = MAX_NUMS_OF_STRING * 2
MAX_NUMS_OF_MODIFY_STRING    = 20


MENU_PAGE_DYNAMIC_MENU    =1
MENU_PAGE_ALARM           =2

class class_menu_group(Thread, class_device_menu) :
    def __init__(self, 
                 device_remap = 0,
                 max_menu_lines = 8, 
                 comm_config : class_comm_device_config = None, 
                 modbus_tcp_server : class_modbus_tcp_server = None):
        
        Thread.__init__(self)
        class_device_menu.__init__(self, device_remap, comm_config)

        self.modbus_tcp_server = modbus_tcp_server
        self.max_menu_lines = max_menu_lines
        self.server = None
        
        self.menu_reg_count = 10000
        self.menu_active = None if self.config == None else self.config.get_menu_top()
        return 

    def menu_get_regsiter_addr(self, row, col) :
        if col == 1:
            addr = modbus_server.REGISTER_MENU_STRING_ROW0_COL1 + row * MAX_NUMS_OF_STRING
        else :
            addr = modbus_server.REGISTER_MENU_STRING_ROW0_COL0 + row * MAX_NUMS_OF_STRING
        return addr

    def register_menu_string_fill(self, addr, menu_str, max_count) :
        index = 0
        for chr in menu_str :
            self.update_server_register(addr + index, ord(chr))
            if index >= max_count - 1:
                break
            index += 1
        self.update_server_register(addr + index, 0)

    def menu_display_string(self, row, col, menu_str) :
        addr = self.menu_get_regsiter_addr(row, col)
        self.register_menu_string_fill(addr, menu_str, MAX_NUMS_OF_STRING)

    def menu_display_modify_caption_string(self, menu_str) :
        addr = modbus_server.REGISTER_MENU_MODIFY_CAPTION_STRING
        self.register_menu_string_fill(addr, menu_str, MAX_NUMS_OF_MODIFY_STRING)
        
    def menu_display_modify_string(self, menu_str) :
        addr = modbus_server.REGISTER_MENU_MODIFY_STRING
        self.register_menu_string_fill(addr, menu_str, MAX_NUMS_OF_MODIFY_STRING)

    def menu_display_modify_select_string(self, menu_str) :
        addr = modbus_server.REGISTER_MENU_MODIFY_SELECT_STRING
        self.register_menu_string_fill(addr, menu_str, MAX_NUMS_OF_MODIFY_STRING)

    def menu_get_value_regs(self, menu_item) :
        comm_str = utils.dict_or_object_get_attr(menu_item, "addr", None)
        value = None
        comm_thread : class_comm_master_thread= None
        comm_device : class_comm_device = None
        comm_device, comm_thread, device_menu = comm_global.search_device_remap_infos(self.device_remap)
       
        if comm_str != None:
            reg_addr, bit, reg_count = utils.comm_str_unpack(comm_str)
            if comm_thread == None or reg_count == 0:
                value = None
            elif bit >= 0:
                start_index = int(bit / 16)
                end_index   = int((bit + reg_count + 15) / 16)
                reg_items   = end_index - start_index
                value = comm_device.read_register_count(reg_addr + start_index, reg_items)
                #value = comm_thread.comm_hold_register_read(comm_addr, reg_addr + start_index, reg_items)
                comm_device.device_comm_flush_request(reg_addr + start_index, reg_items, cycle = 3000)
            else :
                value = comm_device.read_register_count(reg_addr, reg_count)
                #value = comm_thread.comm_hold_register_read(comm_addr, reg_addr, reg_count)
                
                #刷新请求
                comm_device.device_comm_flush_request(reg_addr, reg_count, cycle = 3000)
        return value

    def menu_get_value_scale_float(self, menu_item) :
        comm_str = utils.dict_or_object_get_attr(menu_item, "addr", None)
        reg_addr, bit, reg_count = utils.comm_str_unpack(comm_str)
        value = self.menu_get_value_regs(menu_item)
        is_big_endian = self.menu_data_is_big_endian(menu_item)
        is_float = self.menu_data_is_float(menu_item)
        
        new_value = None
        if value != None :
            if len(value) == 2:
                if is_big_endian:
                    new_value = value[1] + (value[0] << 16)
                else :
                    new_value = value[0] + (value[1] << 16)

                if is_float :
                    bytes = struct.pack('BBBB', new_value & 0xFF, (new_value >> 8) & 0xFF, (new_value >> 16) & 0xFF, (new_value >> 24) & 0xFF)
                    new_value = struct.unpack("<f", bytes)
            elif len(value) == 1:
                new_value = value[0]

            if bit >= 0 and new_value != None and is_float == False:
                bit = bit % 16
                new_value = (new_value >> bit) & (0xFFFFFFFF >> (32 - reg_count))

        if new_value != None : 
            scale = utils.dict_or_object_get_attr(menu_item, "scale", 1.0)
            new_value = new_value * scale
        return new_value

    def menu_get_value(self, menu_item) :
        return self.menu_get_value_scale_float(menu_item)

    def menu_write_value(self, menu_item, new_value) :
        comm_str    = utils.dict_or_object_get_attr(menu_item, "addr", None)
        if comm_str != None and new_value != None:
            reg_addr, bit, reg_count = utils.comm_str_unpack(comm_str)
            
            comm_thread : class_comm_master_thread = None
            comm_device : class_comm_device = None
            comm_device, comm_thread, device_menu = comm_global.search_device_remap_infos(self.device_remap)

            if comm_thread != None and comm_device != None and reg_count == len(new_value) :
                return comm_thread.comm_hold_register_write(comm_device.comm_addr, reg_addr, reg_count, new_value)
        return False

    def menu_get_value_string(self, menu_item) :
        value_str = None
        value = None
        format_str = utils.dict_or_object_get_attr(menu_item, "format", "%f")
        is_big_endian = self.menu_data_is_big_endian(menu_item)
        action_str = utils.dict_or_object_get_attr(menu_item, "action", None)

        if action_str == "time" :
            value = self.menu_get_value_regs(menu_item)
            value_str = self.menu_get_time_string(value)
        elif action_str == "date" :
            value = self.menu_get_value_regs(menu_item)
            value_str = self.menu_get_date_string(value)
        elif action_str == "ip" :
            value = self.menu_get_value_regs(menu_item)
            value_str = self.menu_get_ip_string(value, is_big_endian)
        elif action_str != None:
            return None
        else :
            new_value = self.menu_get_value_scale_float(menu_item)
            if new_value != None : 
                value_str = format_str%(new_value)

        return value_str

    def menu_display_page(self, page) :
        self.update_server_register(modbus_server.REGISTER_MENU_DISPLAY_PAGE, page)

    def menu_popup_modify_status_change(self, active = False) :
        self.update_server_register(modbus_server.REGISTER_MENU_POPUP_MODIFY_ACTIVE, int(active))

    def menu_remap_addr_flush(self, menu_table) :
        if menu_table == None:
            return
        for menu_item in menu_table:
            sub_menu_name = utils.dict_or_object_get_attr(menu_item, "sub_menu", None)
            sub_menu = self.config.get_menu(sub_menu_name)
            
            if sub_menu :
                #子菜单递归调用
                self.menu_remap_addr_flush(sub_menu)
                continue
            remap_addr = utils.dict_or_object_get_attr(menu_item, "remap_addr", None)
            if remap_addr != None :
                #需要加上设备重映射基础地址
                remap_addr += self.device_remap
                new_value = self.menu_get_value_scale_float(menu_item)
                if type(new_value) == float:
                    reg_values = []
                    bs = struct.pack('f', new_value)
                    reg_values.append(bs[0] | bs[1] << 8)
                    reg_values.append(bs[2] | bs[3] << 8)
                    self.update_server_register(remap_addr, reg_values)

    def menu_top_remap_addr_flush(self) :
        self.menu_remap_addr_flush(self.menu_table)
  
    def menu_display(self):
        menu_count = 0
        row = 0
        col = 0
        active_layer  : class_menu_layer_info = self.menu_get_layer_info()
        menu_active = active_layer.menu_active

        menu_index = 0
        for menu_item in menu_active :
            if menu_index  < active_layer.menu_display_start:
                menu_index += 1
                continue

            caption = DEFAULT_EMPTY_STR
            if "name" in menu_item.keys() :
                caption = menu_item["name"]
            col = 0
            self.menu_display_string(row, col, caption)
            
            sub_menu_name = utils.dict_or_object_get_attr(menu_item, "sub_menu", None)
            sub_menu = self.config.get_menu(sub_menu_name)

            if sub_menu != None:
                self.menu_display_string(row, col + 1, " ")
            else :
                alias_str = self.menu_get_alias_value_string(menu_item)
                if alias_str :
                    self.menu_display_string(row, col + 1, alias_str)
                else :
                    value_str = self.menu_get_value_string(menu_item)
                    if value_str != None :
                        unit_str = utils.dict_or_object_get_attr(menu_item, "unit", DEFAULT_EMPTY_STR)
                        value_str = value_str + " " + unit_str
                        self.menu_display_string(row, col + 1, value_str)
                    else :
                        self.menu_display_string(row, col + 1, DEFAULT_EMPTY_STR)

            row = row + 1
            menu_count += 1
            if menu_count >= self.max_menu_lines :
                break

        while row < self.max_menu_lines :
            self.menu_display_string(row, 0, DEFAULT_EMPTY_STR)
            self.menu_display_string(row, 1, DEFAULT_EMPTY_STR)
            row += 1

    def menu_get_alias_dict(self, alias_name) :
        alias_value_dict = None
        if alias_name != None and self.alias_table != None:
            for alias_dict in self.alias_table :
                if alias_name in alias_dict.keys() :
                    alias_value_dict = alias_dict[alias_name]
        return alias_value_dict

    def menu_get_alias_value_string(self, menu_item) :
        alias = utils.dict_or_object_get_attr(menu_item, "alias", None)
        if alias == None :
            return None

        alias_dict = self.menu_get_alias_dict(alias)
        if alias_dict == None :
            return None
        
        value = self.menu_get_value_scale_float(menu_item)
        alias_value_str = None
        if alias_dict != None and value != None:
            alias_value = int(value)
            if alias_value in alias_dict.keys() :
                alias_value_str = alias_dict[alias_value]
        return alias_value_str

    def menu_modify_value_string(self, value_string, unit_string = DEFAULT_EMPTY_STR, caption_string = DEFAULT_EMPTY_STR) :
        sel_bit = 0 
        if value_string == None:
            return None
        
        modify_value_string = value_string
        key = KEYDEF.MENU_PACK_KEY_NULL
        while True :
            key = comm_global.g_key_thread.menu_wait_key(0.1)
            value_string_display = modify_value_string
            if key == KEYDEF.MENU_PACK_KEY_RESET_OR_UP or key == KEYDEF.MENU_PACK_KEY_ESCAPE :
                break
            if key == KEYDEF.MENU_PACK_KEY_DOWN :
                if str.isdigit(modify_value_string[sel_bit]) :
                    modify_value_list = list(modify_value_string)
                    modify_value_list[sel_bit] = chr(ord(modify_value_list[sel_bit]) - 1)
                    if modify_value_list[sel_bit] < '0':
                        modify_value_list[sel_bit] = '9'
                    modify_value_string = ''.join(modify_value_list)
                    
            elif key == KEYDEF.MENU_PACK_KEY_UP :
                if str.isdigit(modify_value_string[sel_bit]) :
                    modify_value_list = list(modify_value_string)
                    modify_value_list[sel_bit] = chr(ord(modify_value_list[sel_bit]) + 1)                    
                    if modify_value_list[sel_bit] > '9':
                        modify_value_list[sel_bit] = '0' 
                    modify_value_string = ''.join(modify_value_list)
                    
            elif key == KEYDEF.MENU_PACK_KEY_ENTER_OR_RIGHT or key == KEYDEF.MENU_PACK_KEY_RIGHT:
                while sel_bit < len(modify_value_string):
                    sel_bit += 1
                    if sel_bit >= len(modify_value_string) :
                        key = KEYDEF.MENU_PACK_KEY_ENTER
                        break
                    if str.isdigit(modify_value_string[sel_bit]) :
                        break
                if sel_bit >= len(modify_value_string):
                    break

            value_string_list = list(value_string_display)
            value_string_list[sel_bit] = ' '
            value_string_display = ''.join(value_string_list)
            
            value_string_display_select  = modify_value_string[0 : sel_bit + 1]
            
            self.menu_display_modify_caption_string(caption_string)
            self.menu_display_modify_string(value_string_display + unit_string)
            self.menu_display_modify_select_string(value_string_display_select)
            
        if key == KEYDEF.MENU_PACK_KEY_ENTER or key == KEYDEF.MENU_PACK_KEY_ENTER_OR_RIGHT:
            return modify_value_string
        return value_string

    def menu_modify_date_menu_item(self, menu_item) :
        origin_value = self.menu_get_value_regs(menu_item)
        value_string = self.menu_get_value_string(menu_item)
        unit_string = utils.dict_or_object_get_attr(menu_item, "unit", DEFAULT_EMPTY_STR)
        new_value_string:str = self.menu_modify_value_string(value_string, unit_string)
        if new_value_string != value_string :
            date_str =  new_value_string.split('-')
            new_value = origin_value

            if len(date_str) == 3:
                new_value = []
                year = int(date_str[0])
                month = int(date_str[1])
                day = int(date_str[2])
                new_value.append(year)
                new_value.append(month)
                new_value.append(day)
            return new_value, True
        else :
            return origin_value, False

    def menu_modify_time_menu_item(self, menu_item) :
        origin_value = self.menu_get_value_regs(menu_item)
        value_string = self.menu_get_value_string(menu_item)
        unit_string = utils.dict_or_object_get_attr(menu_item, "unit", DEFAULT_EMPTY_STR)
        new_value_string:str = self.menu_modify_value_string(value_string, unit_string)
        if new_value_string != value_string :
            date_str =  new_value_string.split(':')
            new_value = origin_value

            if len(date_str) == 3:
                new_value = []
                hour = int(date_str[0])
                minute = int(date_str[1])
                second = int(date_str[2])
                new_value.append(hour)
                new_value.append(minute)
                new_value.append(second)
            return new_value, True
        else :
            return origin_value, False

    def menu_get_date_string(self, date_value) :
        value_string = None
        if date_value != None:
            if len(date_value) == 3 :
                year = date_value[0]
                month = date_value[1]
                day = date_value[2]  
                value_string = "%04d-%02d-%02d"%(year, month, day) 
        return value_string

    def menu_get_time_string(self, time_value) :
        value_string = None
        if time_value != None :
            if len(time_value) == 3 :
                hour = time_value[0]
                minute = time_value[1]
                second = time_value[2]
                value_string = "%02d:%02d:%02d"%(hour, minute, second) 
        return value_string

    def menu_get_ip_string(self, ip_value, is_big_endian = False) :
        value_string:str = None
        if ip_value != None:
            if len(ip_value) == 2:
                if is_big_endian:
                    str_ip1 = "%03d"%(((ip_value[1] >> 0) & 0xFF),)
                    str_ip2 = "%03d"%(((ip_value[1] >> 8) & 0xFF),)
                    str_ip3 = "%03d"%(((ip_value[0] >> 16) & 0xFF),)
                    str_ip4 = "%03d"%(((ip_value[0] >> 24) & 0xFF),)  
                else :
                    str_ip1 = "%03d"%(((ip_value[0] >> 0) & 0xFF),)
                    str_ip2 = "%03d"%(((ip_value[0] >> 8) & 0xFF),)
                    str_ip3 = "%03d"%(((ip_value[1] >> 16) & 0xFF),)
                    str_ip4 = "%03d"%(((ip_value[1] >> 24) & 0xFF),)
                value_string = "%s.%s.%s.%s"%(str_ip1, str_ip2, str_ip3, str_ip4) 
        return value_string

    def menu_get_ip_value(self, ip_str:str) :
        ip = ip_str.split(sep = '.')
        ip_value = []

        if len(ip) == 4 :
            ip0 = int(ip[0])
            ip1 = int(ip[1])
            ip2 = int(ip[2])
            ip3 = int(ip[3])
            ip_value.append((ip0 << 0) | (ip1 << 8))
            ip_value.append((ip2 << 16) | (ip3 << 24))
        return ip_value

    def menu_data_is_big_endian(self, menu_item) :
        comm_str = utils.dict_or_object_get_attr(menu_item, "addr", DEFAULT_EMPTY_STR)
        is_big_endian = False
        if comm_str :
            if "#>" in comm_str :
                is_big_endian = True
        return is_big_endian

    def menu_data_is_float(self, menu_item) :
        comm_str = utils.dict_or_object_get_attr(menu_item, "addr", DEFAULT_EMPTY_STR)
        is_float = False
        if comm_str :
            if "#f" in comm_str :
                is_float = True
        return is_float
     
    def menu_modify_ip_menu_item(self, menu_item) :
        origin_value  = self.menu_get_value_regs(menu_item)
        is_big_endian = self.menu_data_is_big_endian(menu_item)
            
        value_string:str = self.menu_get_ip_string(origin_value, is_big_endian)
        unit_string = DEFAULT_EMPTY_STR
        new_value_string = self.menu_modify_value_string(value_string, unit_string)
        if new_value_string != value_string :
            new_value = self.menu_get_ip_value(new_value_string)
            return new_value, True
        else :
            return origin_value, False

    def menu_update_modify_regs(self, menu_item, old_value_regs, modify_value) :
        comm_str = utils.dict_or_object_get_attr(menu_item, "addr", DEFAULT_EMPTY_STR)
        reg_addr, bit, reg_count = utils.comm_str_unpack(comm_str)
        scale = utils.dict_or_object_get_attr(menu_item, "scale", 1.0)
        is_float = self.menu_data_is_float(menu_item)
        is_big_endian = self.menu_data_is_big_endian(menu_item)

        if modify_value == None :
            return old_value_regs

        modify_regs = None
        if len(old_value_regs) == 2:
            modify_regs = []
            modify_value = modify_value / scale

            if is_float : 
                #把浮点数转换成4字节数, 然后转化成32位整数
                bs = struct.pack("f", modify_value)
                modify_value = bs[0] | (bs[1] << 8) | (bs[2] << 16) | (bs[3] << 24)
            else :
                modify_value = int(modify_value)

            if bit >= 0:
                if is_big_endian :
                    old_value = (old_value_regs[0] << 16) | old_value_regs[1]
                else :
                    old_value = (old_value_regs[1] << 16) | old_value_regs[0]

                clear_mask = (0xFFFFFFFF >> (32 - reg_count)) << bit
                set_mask   = (modify_value << bit) & clear_mask
                modify_value = (old_value & ~clear_mask) | set_mask

            if is_big_endian :
                modify_regs.append((modify_value >> 16) & 0xFFFF)
                modify_regs.append(modify_value & 0xFFFF)     
            else :
                modify_regs.append(modify_value & 0xFFFF)
                modify_regs.append((modify_value >> 16) & 0xFFFF)
        elif  len(old_value_regs) == 1:
            modify_regs = []
            modify_value = int(modify_value / scale)
            if bit >= 0:
                old_value = old_value_regs[0]
                clear_mask = (0xFFFFFFFF >> (32 - reg_count)) << bit
                set_mask   = (modify_value << bit) & clear_mask
                modify_value = (old_value & ~clear_mask) | set_mask
            modify_regs.append(int(modify_value) & 0xFFFF)

        return modify_regs
              
    def menu_modify_normal_menu_item(self, menu_item) ->Tuple[list, bool]:
        old_value_regs = self.menu_get_value_regs(menu_item)
        value_string = self.menu_get_value_string(menu_item)
        
        new_value_string = value_string
        if value_string != None:
            unit_string = utils.dict_or_object_get_attr(menu_item, "unit", DEFAULT_EMPTY_STR)
            new_value_string = self.menu_modify_value_string(value_string, unit_string)

        if new_value_string != value_string and value_string != None:
            modify_value = float(new_value_string)
            new_value_regs = self.menu_update_modify_regs(menu_item, old_value_regs, modify_value)
            return new_value_regs, True
        else :
            return old_value_regs, False
     
    def menu_modify_alias_menu_item(self, menu_item):
        alias = utils.dict_or_object_get_attr(menu_item, "alias", None)
        alias_dict = self.menu_get_alias_dict(alias)
        old_value_regs = self.menu_get_value_regs(menu_item)

        if old_value_regs == None:
            return old_value_regs, False
        
        fvalue = self.menu_get_value_scale_float(menu_item)
        alias_value = int(fvalue)

        alias_value_index = -1
        search_index = 0
        for item in alias_dict.keys():
            if item == alias_value :
                alias_value_index = search_index
                break
            search_index += 1

        if alias_value_index < 0 :
            return old_value_regs, False

        while True :
            key = comm_global.g_key_thread.menu_wait_key(0.1)
            
            if key == KEYDEF.MENU_PACK_KEY_DOWN :
                alias_value_index += 1
                if alias_value_index >= len(alias_dict) :
                    alias_value_index = 0
                    
            elif key == KEYDEF.MENU_PACK_KEY_UP :
                alias_value_index -= 1
                if alias_value_index < 0 :
                    alias_value_index = len(alias_dict) - 1
                    
            new_alias_value = None
            new_alias_str = DEFAULT_EMPTY_STR

            search_index = 0
            for new_alias_value, new_alias_str in alias_dict.items() :
                if search_index == alias_value_index :
                    break
                search_index += 1

            self.menu_display_modify_string(new_alias_str)
            self.menu_display_modify_select_string(new_alias_str)

            if key == KEYDEF.MENU_PACK_KEY_ENTER or key == KEYDEF.MENU_PACK_KEY_ENTER_OR_RIGHT :
                new_value_regs = self.menu_update_modify_regs(menu_item, old_value_regs, new_alias_value)                  
                is_modified = True if (new_value_regs != old_value_regs) else False
                return new_value_regs, is_modified
            if key == KEYDEF.MENU_PACK_KEY_RESET_OR_UP:
                return old_value_regs, False

    def _menu_adjust_select_item(self, increase) :
        active_layer : class_menu_layer_info = self.menu_get_layer_info()

        active_layer.menu_select += increase
        if increase > 0 and active_layer.menu_select >= active_layer.menu_item_count :
            active_layer.menu_select = 0
            
        if active_layer.menu_select < 0 :
            active_layer.menu_select = active_layer.menu_item_count - 1
        
        if active_layer.menu_display_start + self.max_menu_lines <= active_layer.menu_select :
            active_layer.menu_display_start = active_layer.menu_select - self.max_menu_lines + 1

        if active_layer.menu_select < active_layer.menu_display_start :
           active_layer.menu_display_start = active_layer.menu_select
    
    def menu_process(self, key = KEYDEF.MENU_PACK_KEY_NULL) -> Tuple[bool] : 
        active_layer  : class_menu_layer_info = self.menu_get_layer_info()
        if active_layer == None :
            return False

        result = False

        select_row = active_layer.menu_select - active_layer.menu_display_start
        if select_row >= 0:
            self.update_server_register(modbus_server.REGISTER_MENU_ITEM_SELECT_MASK, 0x01 << select_row)
        if key == KEYDEF.MENU_PACK_KEY_UP :
            self._menu_adjust_select_item(-1)
            self.update_server_register(modbus_server.REGISTER_MENU_ITEM_SELECT_MASK, 0x01 << select_row)
        elif key == KEYDEF.MENU_PACK_KEY_DOWN :
            self._menu_adjust_select_item(1)
            self.update_server_register(modbus_server.REGISTER_MENU_ITEM_SELECT_MASK, 0x01 << select_row)
        elif key == KEYDEF.MENU_PACK_KEY_RESET_OR_UP or key == KEYDEF.MENU_PACK_KEY_ESCAPE:
            self.menu_return_to_upper_layer()
        elif key == KEYDEF.MENU_PACK_KEY_ENTER_OR_RIGHT or key == KEYDEF.MENU_PACK_KEY_ENTER :
            menu_item = self.menu_get_active_item()

            #地址映射有效, 修改映射地址
            device_remap = utils.dict_or_object_get_attr(menu_item, "device_remap", None)
            if device_remap != None:
                self.menu_update_device_remap_addr(device_remap)

            function = utils.dict_or_object_get_attr(menu_item, "function", None)
            if function != None :
                device_menu = self
                result = function(device_menu, menu_item)
                if result :
                    return True
                
            sub_menu_name = utils.dict_or_object_get_attr(menu_item, "sub_menu", None)
            sub_menu = self.config.get_menu(sub_menu_name)
            
            if sub_menu :
                self.menu_enter_sub_menu(sub_menu)
                return True
            
            format_str = utils.dict_or_object_get_attr(menu_item, "format", None)
            
            action_str = utils.dict_or_object_get_attr(menu_item, "action", None)
            if action_str == "exit" :
                self.menu_return_to_upper_layer()
                return True
            elif action_str == "exit2" :
                self.menu_return_to_most_upper_layer()
                return True

            self.menu_popup_modify_status_change(active = True)
            changed = False
            new_value = None 

            if action_str == "time":
                new_value, changed = self.menu_modify_time_menu_item(menu_item)
            elif action_str == "date" :
                new_value, changed = self.menu_modify_date_menu_item(menu_item)
            elif action_str == "ip" :
                new_value, changed = self.menu_modify_ip_menu_item(menu_item)
            elif action_str != None :
                return False
            else :
                alias = utils.dict_or_object_get_attr(menu_item, "alias", None)
                if alias != None :
                    new_value, changed = self.menu_modify_alias_menu_item(menu_item)
                else:
                    new_value, changed = self.menu_modify_normal_menu_item(menu_item)
            
            comm_str = utils.dict_or_object_get_attr(menu_item, "addr", DEFAULT_EMPTY_STR)
            reg_addr, bit, reg_count = utils.comm_str_unpack(comm_str)
            
            if changed and new_value != None:    
                comm_device :class_comm_device = None            

                comm_device, comm_thread, device_menu = comm_global.search_device_remap_infos(self.device_remap)
                if comm_thread != None and comm_device != None and reg_count > 0:
                    result = comm_device.write_register(reg_addr, reg_count, new_value)
                    #result = comm_thread.comm_hold_register_write(comm_addr, reg_addr, reg_count, new_value)

            self.menu_popup_modify_status_change(active = False)
        return result

    def update_server_register(self, addr, value) :
        if self.modbus_tcp_server :
            self.modbus_tcp_server.update_server_register(addr, value)

    def run(self) :
        while True:
            key = comm_global.g_key_thread.menu_wait_key(0.1)
            
            page = None
            active_menu = self.menu_get_active_menu()
            if self.config != None :
                page = self.config.menu_get_display_page(active_menu)
            if page == None :
                page = menu_page.KUNLUN_GRAOUP_PAGE_MENU
                
            self.menu_display_page(page)
            self.menu_process(key)
            self.menu_display()

'''
可使用的函数:
创建从站: server.add_slave(slave_id)
    slave_id(int):从站id
为从站添加存储区: slave.add_block(block_name, block_type, starting_address, size)

    block_name(str):block名
    block_type(int):block类型,COILS = 1,DISCRETE_INPUTS = 2,HOLDING_REGISTERS = 3,ANALOG_INPUTS = 4
    starting_address(int):起始地址
    size(int):block大小
设置block值:slave.set_values(block_name, address, values)
    block_name(str):block名
    address(int):开始修改的地址
    values(a list or a tuple or a number):要修改的一个(a number)或多个(a list or a tuple)值
获取block值:slave.get_values(block_name, address, size)
    block_name(str):block名
    address(int):开始获取的地址
    size(int):要获取的值的数量
'''

if __name__ == '__main__':
    comm_device_config: class_comm_device_config = device_9TE.comm_device_config
    _slave_addr  = 2

    _device_remap = 2000
    
    _modbus_tcp_server = class_modbus_tcp_server(slave_addr = _slave_addr,
                                                slave_ip= "192.168.1.54", 
                                                slave_port = 502)

    object_menu_group = class_menu_group(device_remap =_device_remap,
                                         comm_config = comm_device_config,
                                         modbus_tcp_server = _modbus_tcp_server,
                                         max_menu_lines = 8)

    object_menu_group.start()