#-*- coding: UTF-8 -*-
import xlrd
import re
import util
import platform
import os

TAB = "    "

def get_file_name_length(file_path):
    return len(util.get_file_name(file_path))

#type = 1  lua   type = 2  hrl  type = 3  erl
def write_file(string, type, path):
    file_path = path["file_path"]
    folder_path = path["folder_path"]
    dump_path = path["dump_path"]
    tmp = get_file_name_length(file_path) + 4
    if len(file_path) - tmp - len(folder_path) > 1:
        relative_file_path = file_path[len(folder_path)+1:len(file_path)-tmp] #相对路径。生成树形目录
    else:
        relative_file_path = ""

    excel_name = util.get_file_name(file_path)
    if type == 1:
        s = "lua"
        dump_name = (excel_name.lower()) + ".lua"
    elif type == 2:
        s = "hrl"
        dump_name = "config_" + util.to_lower(excel_name) + ".hrl"
    elif type == 3:
        s = "erl"
        dump_name = "config_" + util.to_lower(excel_name) + ".erl"
    elif type == 4:
        s = "map"
        dump_name = "cfg_" + excel_name + ".erl"

    base_path = dump_path + util.SPLIT_STR
    if not os.path.isdir(base_path):
        os.makedirs(base_path)
    if relative_file_path != "":
        paths = relative_file_path.split(util.SPLIT_STR)
        for i in range(len(paths)):
            if platform.system() == "Windows":
                base_path = base_path + util.SPLIT_STR + paths[i]
            else:
                base_path = base_path + paths[i] + "/"
        if not os.path.isdir(base_path):
            os.makedirs(base_path)
        f = open(base_path + dump_name, "w")
        f.write(string)
        f.close()
    else:
        f = open(dump_path + util.SPLIT_STR + dump_name, "w")
        f.write(string)
        f.close()

def to_lua_by_row(row_list, config_sheet, main_key_index, key_data, value_row):
    lua_list = []
    row_obj = {}
    for index in range(len(key_data)):
        # if index == main_key_index:
        #     continue
        # 只导出前端需要的列
        if key_data[index]["key_color"] == 2 or key_data[index]["key_color"] == False:
            continue
        # 忽略非必须导出并且内容为空的cell
        if key_data[index]["key_must"] == False and value_row[index] == "":
            continue
        key_value = key_data[index]["key_name"]
        key_type = key_data[index]["key_type"]
        # lua_list.append(TAB + "[\"" + key_value + "\"] = ")
        value_row_list, row_obj[key_value] = get_value_list(config_sheet, value_row[index], key_type, 0, key_data[index]["is_array"], key_data[index]["key_must"])
        if index != main_key_index:
            lua_list.append(TAB + "[\"" + key_value + "\"] = ")
            # value_row_list.append(",\n")
            lua_list.append("".join(value_row_list))
            lua_list.append(",\n")
    row_list.append(row_obj)
    return ''.join(lua_list)

def write_to_lua(data_sheet, config_sheet, file_name, path):
    file_name_lower = file_name.lower()
    key_data = data_sheet["key_data"]
    main_key_index = data_sheet["main_key_index"]
    value_data = data_sheet["value_data"]
    row_list = []
    lua_list = []
    lua_list.append("local " + file_name_lower + " = {}\n")
    for row in range(len(value_data)):
        main_key_value = get_cell_value_by_type(value_data[row][main_key_index], key_data[main_key_index]["key_type"])
        lua_list.append(file_name_lower + "[" + str(main_key_value) + "] = {\n")
        row_value = to_lua_by_row(row_list, config_sheet, main_key_index, key_data, value_data[row])
        lua_list.append(row_value + "}\n")
    lua_list.append("return " + file_name_lower)
    write_file(''.join(lua_list), 1, path)
    return row_list

def init_rule(excel_data):
    rules = []
    for sheet_name in excel_data.sheet_names():
        if sheet_name == "rule":
            break
    else:
        return rules
    data = excel_data.sheet_by_name("rule")
    nrows = data.nrows
    ncols = data.ncols
    for i in range(nrows):
        if data.cell(i, 0).value == "":
            break
        rule_value_list = []
        for j in range(ncols):
            value = data.cell(i, j).value
            if value == "":
                break
            rule_value_list.append(value)
        rules.append(rule_value_list)
    return rules

def read_config_sheet(excel_data):
    config_data = {}
    for sheet_name in excel_data.sheet_names():
        if sheet_name == "config":
            break
    else:
        return None
    data = excel_data.sheet_by_name("config")
    nrows = data.nrows
    ncols = data.ncols
    for i in range(nrows):
        key_value = data.cell(i, 0).value
        if key_value == "":
            continue
        config_data[key_value] = []
        for j in range(1, ncols):
            value = data.cell(i, j).value
            if value == "":
                continue
            if value != "":
                variable_obj = {}
                array = value.split(":")
                xy = data.cell_xf_index(i, j)
                index_color = excel_data.xf_list
                colortype = index_color[xy].background.pattern_colour_index
                must = util.get_color_type(colortype)
                variable_obj["variable_name"] = array[0]
                variable_obj["variable_type"] = array[1]
                variable_obj["is_must"] = must
                config_data[key_value].append(variable_obj)
    return config_data

def read_data_sheet(excel_data):
    data = excel_data.sheet_by_index(0)
    nrows = data.nrows
    ncols = data.ncols

    key_row_index = 0
    type_row_index = 0
    value_row_index = 0
    flag = 0
    name_rows = None
    type_rows = None
    for row in range(nrows):
        rowvalue = data.row_values(row)
        tmp = unicode(rowvalue[0])
        if not re.search(r"^//", tmp) and re.search(r"^\S", tmp):
            if flag == 0:
                key_row_index = row
                name_rows = rowvalue
                flag = 1
            else:
                type_row_index = row
                value_row_index = row + 1
                type_rows = rowvalue
                break
    if name_rows is None or type_rows is None:
        return None

    max_col = len(name_rows)
    for col in range(len(name_rows), 1, -1):
        if name_rows[col-1] != "":
            max_col = col
            break

    key_data = []
    main_key_index = None
    for col in range(max_col):
        key_obj = {}
        if name_rows[col] != "":
            is_key = util.is_key(name_rows[col])
        else:
            is_key = False
        if is_key:
            if main_key_index is None:
                main_key_index = col
            key_obj["key_name"] = name_rows[col][1:]
        else:
            key_obj["key_name"] = name_rows[col]
        key_obj["key_type"] = type_rows[col]
        if type_rows[col] != "":
            key_obj["is_array"] = util.is_array(type_rows[col])
        else:
            key_obj["is_array"] = False

        index_color = excel_data.xf_list
        xy = data.cell_xf_index(key_row_index, col)
        colortype = index_color[xy].background.pattern_colour_index
        color = util.get_color_type(colortype)
        key_obj["key_color"] = color

        xy = data.cell_xf_index(type_row_index, col)
        colortype = index_color[xy].background.pattern_colour_index
        must = util.get_color_type(colortype)
        key_obj["key_must"] = must

        key_data.append(key_obj)
    if main_key_index is None:
        main_key_index = 0

    value_data = []
    for row in range(value_row_index, nrows):
        if data.cell(row, 0).value == "":
            continue
        row_data = []
        value_data.append(row_data)
        for col in range(max_col):
            row_data.append(data.cell(row, col).value)

    main_data = {}
    main_data["key_data"] = key_data
    main_data["main_key_index"] = main_key_index
    main_data["value_data"] = value_data
    return main_data

def check_item_extra_rule(obj, variable_list, index, variable_value, operator):
    if isinstance(obj, dict):
        if len(variable_list) >= index + 1:
            if obj.has_key(variable_list[index]):
                return check_item_extra_rule(obj[variable_list[index]], variable_list, index + 1, variable_value, operator)
    elif isinstance(obj, list):
        # 如果筛选rule是某个数组里的某个属性，那么这个数组里只要有一个元素满足条件，rule就算成立
        check_rule = False
        for i in range(len(obj)):
            if check_item_extra_rule(obj[i], variable_list, index, variable_value, operator):
                check_rule = True
                break
        return check_rule
    else:
        if operator == "==":
            if variable_value != obj:
                return False
        elif operator == "!=":
            if variable_value == obj:
                return False
    return True

def get_item(dict_or_list, obj, variable_list, index, type_list, type_value, operator):
    if isinstance(obj, dict):
        check_result = False
        # 额外的筛选rule
        if type_list is not None:
            if len(type_list) == index + 1:
                if check_item_extra_rule(obj, type_list, index, type_value, operator):
                    check_result = True
                else:
                    return
            elif variable_list[index] != type_list[index]:
                if check_item_extra_rule(obj, type_list, index, type_value, operator):
                    check_result = True
                else:
                    return
        if len(variable_list) >= index + 1:
            if obj.has_key(variable_list[index]):
                # 如果为true说明已经判断过rule并且通过，后面就不用再判断rule
                if check_result:
                    get_item(dict_or_list, obj[variable_list[index]], variable_list, index + 1, None, type_value, operator)
                else:
                    get_item(dict_or_list, obj[variable_list[index]], variable_list, index + 1, type_list, type_value, operator)
    elif isinstance(obj, list):
        for i in range(len(obj)):
            get_item(dict_or_list, obj[i], variable_list, index, type_list, type_value, operator)
    else:
        if isinstance(dict_or_list, dict):
            dict_or_list[str(obj)] = 1
        elif isinstance(dict_or_list, list):
            dict_or_list.append(str(obj))

def get_item_value(excel_obj, dict_or_list, keys, types):
    key_list = keys.split(".")
    main_key_index = excel_obj["data_sheet"]["main_key_index"]
    key_data = excel_obj["data_sheet"]["key_data"]
    rows = excel_obj["rows"]
    # 如果有额外的筛选规则
    type_list = None
    type_value = None
    operator = "=="
    if types:
        m = re.search(r"==|!=", types)
        if m is not None:
            operator = str(m.group())
            tmp = types.split(operator)
            type_value = tmp[1]
            type_list = tmp[0].split(".")
    for i in range(len(rows)):
        if rows[i].has_key(key_list[0]):
            if isinstance(dict_or_list, list):
                row_list = []
                get_item(row_list, rows[i], key_list, 0, type_list, type_value, operator)
                dict_or_list.append(row_list)
            else:
                get_item(dict_or_list, rows[i], key_list, 0, type_list, type_value, operator)
    return dict_or_list

def get_item_value_dict(excel_obj, keys, types=False):
    return get_item_value(excel_obj, {}, keys, types)

def get_item_value_list(excel_obj, keys, types=False):
    return get_item_value(excel_obj, [], keys, types)

def get_main_key(excel_obj):
    return excel_obj["data_sheet"]["main_key_index"]

def get_value_data(excel_obj):
    return excel_obj["data_sheet"]["value_data"]

def get_rules(excel_obj):
    return excel_obj["rules"]

def get_value_list(config_sheet, cell_value, key_type, deep, is_array, is_must):
    check_cell_value(cell_value, key_type, is_array, is_must)
    value_row_list = []
    value_row_obj = None
    if is_array:
        key_type = key_type[1:-1]
        if config_sheet is not None and config_sheet.has_key(key_type):
            value_row_list, value_row_obj = get_value_with_config(config_sheet, cell_value, config_sheet[key_type], deep, is_array, is_must)
        else:
            value_row_list, value_row_obj = cell_value_to_lua_string(key_type, cell_value[1:-1], deep, is_array, is_must)
    else:
        if config_sheet is not None and config_sheet.has_key(key_type):
            value_row_list, value_row_obj = get_value_with_config(config_sheet, cell_value, config_sheet[key_type], deep, is_array, is_must)
        else:
            value_row_list, value_row_obj = cell_value_to_lua_string(key_type, cell_value, deep, is_array, is_must)
    return value_row_list, value_row_obj

def get_value_with_config(config_sheet, cell_value, config_data, deep, is_array, is_must):
    value_list = []
    value_obj = None
    if is_array:
        strings = util.split_string(cell_value[1:-1])
        value_list.append(deep*TAB + "{")
        first_item = True
        value_obj = []
        for i in range(len(strings)):
            value_obj2 = {}
            strings2 = util.split_string(strings[i][1:-1])
            # 为了和上一版本的脚本导出后的结果一模一样而做的处理
            if first_item == True:
                first_item = False
            else:
                value_list.append(",")
            value_list.append("\n" + (deep+2)*TAB + "{\n")
            first_item_strings2 = True
            for j in range(len(strings2)):
                if (not config_data[j]["is_must"]) and (strings2[j] == "" or strings2[j] == "NULL" or strings2[j] == "null"):
                    continue
                variable_type = config_data[j]["variable_type"]
                variable_type_is_array = util.is_array(variable_type)
                # 为了和上一版本的脚本导出后的结果一模一样而做的处理
                if first_item_strings2 == True:
                    first_item_strings2 = False
                else:
                    value_list.append(",\n")
                value_list.append((deep+3)*TAB + "[\"" + config_data[j]["variable_name"] + "\"] = ")
                value_row_list, obj = get_value_list(config_sheet, strings2[j], variable_type, deep + 2, variable_type_is_array, is_must)
                value_obj2[str(config_data[j]["variable_name"])] = obj
                value_list.append("".join(value_row_list))
            value_obj.append(value_obj2)
            value_list.append("\n" + (deep+2)*TAB + "}")
        value_list.append("\n" + (deep+1)*TAB + "}")
    else:
        strings = util.split_string(cell_value[1:-1])
        value_list.append("{\n")
        first_item = True
        value_obj = {}
        for i in range(len(strings)):
            variable_type = config_data[i]["variable_type"]
            variable_type_is_array = util.is_array(variable_type)
            # 为了和上一版本的脚本导出后的结果一模一样而做的处理
            if first_item == True:
                first_item = False
            else:
                value_list.append(",\n")
            value_list.append((deep+2)*TAB + "[\"" + config_data[i]["variable_name"] + "\"] = ")
            value_row_list, obj = get_value_list(config_sheet, strings[i], variable_type, deep, variable_type_is_array, is_must)
            value_obj[str(config_data[i]["variable_name"])] = obj
            value_list.append("".join(value_row_list))
        value_list.append("\n" + (deep+1)*TAB + "}")
    return value_list, value_obj

def cell_value_to_lua_string(key_type, cell_value, deep, is_array, is_must):
    value_list = []
    value_obj = None
    if is_array:
        value_obj = []
        strings = util.split_string(cell_value)
        value_list.append("{\n")
        first_item = True
        for i in range(len(strings)):
            # 为了和上一版本的脚本导出后的结果一模一样而做的处理
            if first_item == True:
                first_item = False
            else:
                value_list.append(",\n")
            value_list.append((deep+2)*TAB)
            value = get_cell_value_by_type(strings[i], key_type)
            value_obj.append(value)
            value_list.append(value)
        value_list.append("\n" + (deep+1)*TAB + "}")
    else:
        value = get_cell_value_by_type(cell_value, key_type)
        value_obj = value
        value_list.append(value)
    return value_list, value_obj

def get_cell_value_by_type(value, value_type):
    if value_type == "string" or value_type == "atom":
        value = str(value)
        if value[0] == "\"" or value[0] == "\“":
            if value[-1] != "\"":
                raise EOFError(u"引号填写有误")
            value = value[1:-1]
        value = "\"" + value + "\""
    elif value_type == "int" or value_type == "int32":
        value = str(int(value))
    else:
        value = str(value)
    return value


def check_cell_value(value, value_type, is_array, is_must):
    if is_array or (not util.is_base(value_type)):
        if (not is_must) and (value == "" or value == "NULL" or value == "null"):
            return
        if is_array:
            if value[0] != "[" or value[-1] != "]":
                raise EOFError(u"数组缺括号")
        else:
            if value[0] != "{" or value[-1] != "}":
                raise EOFError(u"复合类型缺括号")
    else:
        if is_must and value == "":
            raise EOFError(u"缺少必填项")
        if value_type == "string" or value_type == "atom":
            value = str(value)
            if value[-1] == "\"" and value[0] != "\"":
                raise EOFError(u"引号填写有误")
            if value[0] == "\"" or value[0] == "\“":
                if value[-1] != "\"":
                    raise EOFError(u"引号填写有误")
        elif value_type == "int" or value_type == "int32":
            try:
                if abs(int(value) - float(value)) > 1e-5:
                    raise EOFError(u"整数类型填写有误")
            except:
                raise EOFError(u"整数类型填写有误")
        elif value_type == "float":
            try:
                float(value)
            except:
                raise EOFError(u"浮点型填写有误")


def convert(path):
    excel_data = xlrd.open_workbook(path["file_path"], formatting_info=True)
    file_name = util.get_file_name(path["file_path"])

    config_sheet = read_config_sheet(excel_data)
    data_sheet = read_data_sheet(excel_data)
    rules = init_rule(excel_data)
    rows = write_to_lua(data_sheet, config_sheet, file_name, path)
    excel_data.release_resources()
    del excel_data

    excel_obj = dict()
    excel_obj["file_name"] = os.path.basename(path["file_path"])
    excel_obj["file_path"] = path["file_path"]
    excel_obj["data_sheet"] = data_sheet
    excel_obj["rows"] = rows
    excel_obj["rules"] = rules

    print "convert " + file_name + " finish"
    return excel_obj