###################################################################
##
##  tools
##

def (dict_temp):
	"""Count dictionary's deep

		Args:
			dict_temp: dict

		Returns:
			int : deep
	"""

    deep = 0
    for item in dict_temp.values():
        if isinstance(item, dict):
            temp_deep = count_dict_deep(item)
            if temp_deep > deep:
                deep = temp_deep

    return deep+1

def calc_weight(obj1):
	"""Calculate obj's weight

		Args:
			obj1: tuple[dict's string, dict's frequency]
		
		Returns:
			int : weight
	"""

    dict1 = eval(obj1[0])
    times1 = obj1[1]

    deep1 = count_dict_deep(dict1)
    ans = deep1 + 1/times1

    return ans

def count_table_frequency(unit_dict, dict_frequency):
    """Count table frequency
        
        Count table frequency and record as {table string: times}

        Args:
            unit_dict: dict, need analyse data
            dict_frequency: dict, the record's set
    """

    unit_str = str(unit_dict)
    if unit_str in dict_frequency:
        dict_frequency[unit_str] = dict_frequency[unit_str] + 1
    else:
        dict_frequency[unit_str] = 1

    # traversing sub dict
    for item in unit_dict.values():
        if isinstance(item, dict):
            count_table_frequency(item, dict_frequency)


def count_table_value_frequency(key, value, item_frequency):
    """Count table value frequency

        Count every excel column element appear times.
        Record as {
                    key1 : {element1 : times, element2: times, ...}
                    key2 : {element1 : times, element2: times, ...}
                    ...
                    }

        Args:
            key: string
            value: string or dict
            item_frequency: dict, the record's set
    """

    if isinstance(value, dict):
        value = str(value)

    if key in item_frequency.keys():
        if value in item_frequency[key].keys():
            item_frequency[key][value] = item_frequency[key][value] + 1
        else:
            item_frequency[key][value] = 1
    else:
        item_frequency[key] = {}
        item_frequency[key][value] = 1


def traverse_table(excel_dict, dict_frequency, item_frequency):
    """Traverse table.
        
        Analyse lua table.

        Args:
            excel_dict: dict
            dict_frequency: dict
            item_frequency: dict
    """

    for key in sorted(excel_dict):
        if isinstance(excel_dict[key], dict):
            count_table_frequency(excel_dict[key], dict_frequency)

            for k, v in excel_dict[key].items():
                count_table_value_frequency(k, v, item_frequency)


def check_repeat_dict(item_dict, repeat_dict):
    """Check repeat dict
        
        Check repeat dict and return the repeat index, if not exist in repeat dict return -1.

        Args:
            item_dict: dict
            repeat_dict: dict

        Returns:
            int
    """

    dict_str = str(item_dict)
    if dict_str in repeat_dict.keys():
        return repeat_dict[dict_str]
    else:
        return -1

def replace_repeat_dict(item_dict, repeat_dict, cur_index = -1):
    """Replace repeat dict

        Check if element exist in repeat dict and replace by designation string.
    
        Args:
            item_dict: dict
            repeat_dict: dict
    """

    cur_index = -1

    for key, value in item_dict.items():
        if isinstance(value, dict):
            index = check_repeat_dict(value, repeat_dict)
            if index != -1 and (index < cur_index or cur_index == -1):
                if index > 190:
                    item_dict[key] = REPEAT_KEY_PREFIX + '[' + str(index - LOCAL_TABLE_MAX) + ']'
                else:
                    item_dict[key] = REPEAT_KEY_PREFIX + str(index)
            else:
                replace_repeat_dict(value, repeat_dict, cur_index)



def output_file(table_name, file_path, repeat_dict, final_dict, default_dict):
    """Output file

        Args:
            table_name: string
            file_path: path
            repeat_dict: dict
            final_dict: dict
            default_dict: dict
    """

    file_handler = codecs.open(file_path, 'a', encoding='utf-8')

    # output repeat dict
    for dictStr, index in sorted(repeat_dict.items(), key=lambda item:item[1]):

        # replace repeat item by repeat_dict 
        repeat_dict_item = eval(dictStr)
        replace_repeat_dict(repeat_dict_item, repeat_dict, index)

        if index <= LOCAL_TABLE_MAX:
            # file_handler.write("local %s = {n" % (REPEAT_KEY_PREFIX + str(index)))
            file_handler.write("local %s = {n" % (REPEAT_KEY_PREFIX + str(index)))
            convert.convert_dict_lua_file(file_handler, repeat_dict_item, 1)
            file_handler.write("}n")
        else:
            if index == (LOCAL_TABLE_MAX + 1):
                file_handler.write("nlocal __rt = createtable and createtable(%d, 0) or {}n" % (len(repeat_dict)-LOCAL_TABLE_MAX))
            
            file_handler.write("__rt[%d] = {n" % (index - LOCAL_TABLE_MAX))
            convert.convert_dict_lua_file(file_handler, repeat_dict_item, 1)
            file_handler.write("}n")       

    # output final dict
    replace_repeat_dict(final_dict, repeat_dict)
    file_handler.write("nlocal %s = {n" % (table_name))
    convert.convert_dict_lua_file(file_handler, final_dict, 1)
    file_handler.write("}n")

    # output default dict