#!/usr/bin/python3
# -*- coding: UTF-8 -*-
from pickletools import read_int4
from traceback import print_tb
import util
import os
import re
import type_deal

# return {head_list, name_list, type_list, export_color, lang_color, data}
def read_data_new(get_max_row, get_max_col, access, _access_color, path, get_rows=None):
    max_row = get_max_row()
    max_col = get_max_col()
    status = 'export_row'
    head_row, export_row, name_row, type_row, data_row = 0, 0, 0, 0, 0
    head_list, export_list, name_list, type_list, data_list = [], [], [], [] ,[]

    # 查到第一行有用数据的row_index
    start_i = 0
    for i in range(10):
        col_1 = access(i, 0)
        if not col_1:
            continue
        if not isinstance(col_1, str):
            continue
        if col_1.startswith("//"):
            continue
        start_i = i
        break

    # print(u"测试数据 startRow %d" % start_i)
    # 查到列导出类型、name、字段type以及实际数据的row_index
    for i in range(start_i, 10):
        if status in ('export_row', ):
            export_row = i
            for j in range(max_col):
                export_list.append(access(i, j))
            status = 'name_row'
        elif status in ('name_row', ):
            name_row = i
            for j in range(max_col):
                name_list.append(access(i, j))
            status = 'type_row'
        elif status in ('type_row', ):
            type_row = i
            data_row = i + 1
            for j in range(max_col):
                type_list.append((access(i, j)))
            break
        else:
            raise Exception('unknown error')

    max_col = len(type_list)
    while not type_list[max_col-1]:
        max_col -= 1
    type_list = type_list[:max_col]

    if data_row == 0:
        raise Exception("excel file data is wrong")

    data_list = []
    spaceRowCountDown = 0
    space_row_list = []

    spaceCloCountDown = 0
    for i in range(0, get_max_col()):
        row_1 = access(0, i)
#            if col_1 is None or col_1 == "":
#                continue
        if row_1 is None or row_1 == "":
            spaceCloCountDown += 1
            if spaceCloCountDown >= 10:
                raise Exception("file name %s more than ten space column" % path)
                break
            else:
                continue
        else:
            spaceCloCountDown = 0

    if get_rows:
        rows = get_rows()
        cur_row = 0
        for row in rows:
            cur_row += 1
            if cur_row - 1 < data_row:
                continue
            one_row = []
            col_1 = row[0].value
            if col_1 is None or col_1 == "":
                space_row_list.append(cur_row)
                spaceRowCountDown += 1
                if spaceRowCountDown >= 10:
                    raise Exception("file name %s more than ten space row" % path)
                    break
                else:
                    continue
            else:
                spaceRowCountDown = 0
            for j in range(max_col):
                v = row[j].value
                if v is None:
                    one_row.append("")
                else:
                    
                    one_row.append(v)
            data_list.append(one_row)
    else:
        for i in range(data_row, max_row):
            one_row = []
            col_1 = access(i, 0)
            if col_1 is None or col_1 == "":
                spaceRowCountDown += 1
                if spaceRowCountDown >= 10:
                    raise Exception("file name %s more than ten space row" % path)
                    break
                else:
                    continue
            else:
                spaceRowCountDown = 0
            for j in range(max_col):
                v = access(i, j)
                if v is None:
                    one_row.append("")
                else:
                    v = v.encode("UTF-8")
                    one_row.append(v)
            data_list.append(one_row)

    return {
        'head_row': head_row,
        'export_row': export_row,
        'name_row': name_row,
        'type_row': type_row,
        'data_row': data_row,
        'head_list': head_list,
        'export_list': export_list,
        'name_list': name_list,
        'type_list': type_list,
        'data_list': data_list,
        'space_row_list': space_row_list,
    }

def xlsx_read_new(path):
    from openpyxl import load_workbook
    wb = load_workbook(path, data_only=True)
    data = []
    data_read = False
    for sheet in wb:
        gmr, gmc, access, access_color, get_rows = util.xlsx_get_function(sheet)
        if not data_read:
            data = read_data_new(gmr, gmc, access, access_color, path, get_rows)
            data_read = True
    wb.close()
    return {
        'data': data,
    }

def create_dirs(path_info, customPath = None):
    src_folder = path_info['folder_path']
    dest_folder = path_info['dump_path']
    file_path = path_info['file_path']

    dest_file_path = file_path.replace(src_folder, dest_folder)
    deep_dir = os.path.dirname(dest_file_path)
    if customPath != None:
        deep_dir = customPath
    if not os.path.isdir(deep_dir):
        try:
            os.makedirs(deep_dir)
        except Exception as e:
            print (str(e))
    if not os.path.isdir(deep_dir):
        raise Exception("could not create dir(%s)" % deep_dir)
    return deep_dir


def convert(path, struct_config, config=None):
    os.path.relpath(path['file_path'], path['folder_path'])
    excel_data = xlsx_read_new(path['file_path'])
    excel_data["config"] = struct_config

    excel_objs = []
    match_result = re.match('.+strings', path['file_path'])

    if match_result:
        #对多语言相关表进行特殊处理
        name_type_dict = dict()
        main_keys = []
        none_count = 0
        for i in range(len(excel_data['data']['name_list'])):
            if i == 0 or excel_data['data']['export_list'][i] == 'none':
                continue

            name = excel_data['data']['name_list'][i]
            if name == None:
                none_count = none_count + 1
                if none_count > 10:
                    raise Exception('more than ten none column xx-xx  path string/%s' % os.path.basename(path['file_path']))
                    return
                continue

            if name.startswith('*'):
                main_keys.append(i)
                continue

            split_data = name.split('-')
            if len(split_data) != 2 and (not name.startswith('*')):
                raise Exception('local config name is not xx-xx(lanuage) path string.%s ' % os.path.basename(path['file_path']))
                return

            excel_data['data']['name_list'][i] = split_data[0]
            if not name_type_dict.get(split_data[1]):
                name_type_dict[split_data[1]] = []
            name_type_dict[split_data[1]].append(i)


        #除id外主键加入
        for language, indexs in name_type_dict.items():
            for main_key_index in main_keys:
                indexs.append(main_key_index)

        for language, indexs in name_type_dict.items():
            excel_tmp_data = {
                'data' : {
                    'head_row' : excel_data['data']['head_row'],
                    'export_row' : excel_data['data']['export_row'],
                    'name_row' : excel_data['data']['name_row'],
                    'type_row' : excel_data['data']['type_row'],
                    'data_row' : excel_data['data']['data_row'],
                    'space_row_list' : excel_data['data']['space_row_list'],
                },
                'config' : excel_data['config']
            }

            excel_tmp_data['data']['head_list'] = []
            excel_tmp_data['data']['name_list'] = []
            excel_tmp_data['data']['type_list'] = []
            excel_tmp_data['data']['export_list'] = []
            excel_tmp_data['data']['data_list'] = []

            #添加主键
            excel_tmp_data['data']['name_list'].append(excel_data['data']['name_list'][0])
            excel_tmp_data['data']['type_list'].append(excel_data['data']['type_list'][0])
            excel_tmp_data['data']['export_list'].append(excel_data['data']['export_list'][0])
            data_row = len(excel_data['data']['data_list'])
            for w in range(data_row):
                excel_tmp_data['data']['data_list'].append([])
                excel_tmp_data['data']['data_list'][w].append(excel_data['data']['data_list'][w][0])

            for i in range(len(indexs)):
                index = indexs[i]
                excel_tmp_data['data']['name_list'].append(excel_data['data']['name_list'][index])
                excel_tmp_data['data']['type_list'].append(excel_data['data']['type_list'][index])
                excel_tmp_data['data']['export_list'].append(excel_data['data']['export_list'][index])

                for j in range(data_row):
                    excel_tmp_data['data']['data_list'][j].append(excel_data['data']['data_list'][j][index])

            deep_dir = os.path.join(path['dump_path'], 'strings')
            deep_dir = os.path.join(deep_dir, language)
            create_dirs(path, deep_dir)
            excel_obj = conver_pri(excel_tmp_data, path, deep_dir, config)
            if excel_obj:
                excel_objs.append(excel_obj)  
    else:
        deep_dir = create_dirs(path)
        excel_obj = conver_pri(excel_data, path, deep_dir, config)
        if excel_obj:
            excel_objs.append(excel_obj)
    return excel_objs


def conver_pri(excel_data, path, deep_dir, config=None):
    file_name = os.path.basename(path['file_path']).split('.')[0]
    reldir = os.path.relpath(os.path.dirname(path['file_path']), path['folder_path'])
    package_name = 'config'
    if reldir == ".":
        if config.get('go_package'):
            package_name = config.get("go_package", "config")
    else:
        package_name = os.path.basename(reldir)

    kts, type_mapping = type_deal.format_key_type_list(excel_data['data']['name_list'], excel_data['data']['type_list'],
                                             excel_data['data']['export_list'], excel_data['config'])

    #如果所有字段都为服务器需要或None则客户端不需要导出
    if type_deal.need_export_table(kts):
        return None

    key_set, full_data = type_deal.construct_data(path, kts, type_mapping, excel_data['data']['data_list'], excel_data['data']['space_row_list'])

    erl_suffix = 'erl'
    lua_suffix = 'lua'
    go_suffix = 'go'
    lua_compact = False
    if config and config.get('erl_suffix'):
        erl_suffix = config['erl_suffix']
    if config and config.get('lua_suffix'):
        lua_suffix = config['lua_suffix']
    if config and config.get('lua_compact'):
        lua_compact = True

    if config and config.get('erlang'):
        erl_data = type_deal.construct_erl_data(kts, type_mapping, key_set, full_data, file_name, '\t')
        write_file(os.path.join(deep_dir, 'cfg_%s.%s' % (file_name, erl_suffix)), erl_data)
        del erl_data

    if config and config.get('lua'):
        lua_data = type_deal.construct_lua_data(path, kts, type_mapping, key_set, full_data, file_name, lua_compact, '\t')
        name = '%s.%s' % (file_name, lua_suffix)
        if config and config.get('lua_force_lowercase', False):
            name = name.lower()
        write_file(os.path.join(deep_dir, name), lua_data)
        del lua_data

    if config and config.get('go'):
        go_data = type_deal.construct_go_data(kts, type_mapping, key_set, full_data, file_name, package_name, '\t')

        name = 'cfg_%s.%s' % (file_name, go_suffix)
        name = name.lower()
        write_file(os.path.join(deep_dir, name), go_data)
        del go_data

    excel_obj = dict()
    excel_obj["file_name"] = os.path.basename(path["file_path"])
    excel_obj["file_path"] = path["file_path"]
    excel_obj["data"] = full_data
    excel_obj["key_set"] = key_set
    excel_obj["kts"] = kts
    excel_obj["type_mapping"] = type_mapping
    excel_obj["space_row_list"] = excel_data['data']['space_row_list']
    return excel_obj

def write_file(file_path, data):
    f = open(file_path, "w", encoding="utf-8")
    f.write(data)
    f.close()