# codinf:utf-8
from flask import render_template, Response,request,redirect,url_for,send_from_directory
# from flask_socketio import SocketIO, emit, disconnect
from random import choice
import json
import time
import csv
import threading
import os
import re
from time import sleep
from config import Config
from app import app,babel
from app.utils.serial_communication import SerialCommunication
# from utils.serial_collection import Communication
from app.utils.location import Location 
from app.scan_collection import first_filter,change_deatil,reset_value
from app.induction_config import read_addrs,remove_a
import logging
from flask_babel import Babel, gettext as _
import serial
import timeit
# from serial_config import ReadConfig
#serl=None
curren_l = 'zh'
scan_state = False
config_dict,convert_dict = Location().read_location_file()
option_list = Location().init_location_option()
#ser = SerialCommunication()
# state_addr = []
basepath = os.path.dirname(__file__)
uploads_path = basepath + Config.UPLOAD_FOLDER
COLORS = Config.COLORS

@babel.localeselector
def get_locale():
    # if the user has set up the language manually it will be stored in the session,
    # so we use the locale from the user settings
    try:
        language = curren_l
    except KeyError:
        language = None
    if language is not None:
        return language
    return request.accept_languages.best_match(app.config['LANGUAGES'].keys())
    
@app.route('/language/<language>')
def set_language(language=None):
    global curren_l
    curren_l = language
    return redirect(url_for('induction_control'))

@app.route('/')
@app.route('/induction_control')
def induction_control():
    logging.warning("控制界面")
    return render_template('induction_control.html')


@app.route('/induction_test')
def induction_test():
    logging.warning("测试界面")
    option_list = load_location_config()
    return render_template('induction_test.html',option_list=option_list,colors=COLORS)

@app.route('/induction_config')
def induction_config():
    logging.warning("配置界面")
    return render_template('induction_config.html')

@app.route('/induction_admin')
def induction_admin():
    return render_template('induction_admin.html')

# 下载日志文件
@app.route('/download/', methods=['GET'], strict_slashes=False)
def download():
    log_path = '/prog/smartshelf/logs/'
    ls=os.path.join(log_path, 'smart.log')
    if request.method == "GET":
        if os.path.isfile(os.path.join(log_path, 'smart.log')):
            return send_from_directory(log_path, 'smart.log', as_attachment=True)

def load_location_config():
    global config_dict
    global option_list
    global convert_dict
    config_dict,convert_dict = Location().read_location_file()
    option_list = Location().init_location_option()
    return option_list


def checkscan(func):
    def wrapper(*args):
        global scan_state
        if scan_state == False:
            return func(*args)
        else:
            return json.dumps({'msg':'库位扫描测试中,请先关闭库位扫描'})
    return wrapper

def deal_allcommand(color):
    texts = []
    # commands = []
    addrs = read_addrs()
    addrs_string=addrs.split('@')
    addr_list = filter(None,list(map(remove_a,addrs)))
    # addr_list = list(filter(None, addr_list))
    for addr in addr_list:
        color_index = color[0]
        leds = [1,100]
        leds.insert(0,color_index)
        text = {}
        text['ADDR'] = addr
        text['ledrange'] = leds
        # texts += str(json.dumps(text), separators=(',',':')) + '\n'
        texts.append(str(json.dumps(text, separators=(',',':'))) + '\n')
    return texts


def process_linetest(data):
    new_channel_nums = data['channel_num']
    color=COLORS.get(data['channel_color'],[15,255,255,255])
    addr_length = len(new_channel_nums)
    texts = ""
    # addrs = read_addrs()
    # addrs_string=addrs.split('@')
    # addr_list = map(remove_a,addrs)
    if new_channel_nums == 'all':
        # addr = "99"
        texts = deal_allcommand(color)
    else:
        addr = new_channel_nums
        color_index = color[0]
        leds = [1,100]
        leds.insert(0,color_index)
        text = {}
        text['ADDR'] = addr
        text['ledrange'] = leds
        texts += str(json.dumps(text)) + '\n'
    return texts


@app.route('/indlineledon', methods=['POST'])
# @checkscan
def indlineledon():
    ser=SerialCommunication();
    data = request.get_json()
    texts = process_linetest(data)
    logging.warning("指令：{}".format(texts))
    if isinstance(texts,list):
        for line in texts:
            ser.send_data(line)
            time.sleep(0.1)
    else:
        ser.send_data(texts)
    msg = "地址：{},颜色：{},已发送开启指令".format(data['channel_num'],data['channel_color'])
    logging.warning(msg)
    c_dict = {'msg':msg}
    return json.dumps(c_dict)

@app.route('/indlineledoff', methods=['POST'])
def indlineledoff():
    ser=SerialCommunication();
    data = request.get_json()
    texts = process_linetest(data)
    logging.warning("指令：{}".format(texts))
    if isinstance(texts,list):
        for line in texts:
            ser.send_data(line)
            time.sleep(0.1)
    else:
        ser.send_data(texts)
    msg = "灯条：{}已关闭".format(data['channel_num'])
    logging.warning(msg)
    c_dict = {'msg':msg}
    return json.dumps(c_dict)

# 处理库位操作测试>>亮灯/灭灯操作
def process_lightindex(data):
    color = COLORS.get(data['light_led_color'],[15,255,255,255])
    light_led = data['light_led']
    Aaddr = config_dict.get(light_led).split('@')[1]
    addr = re.findall("\d+",Aaddr)[0]
    led_index = config_dict.get(light_led).split('@')[0]
    texts = ""
    # colorcommand = {"ADDR":addr,"colorset":[color]}
    # texts += str(json.dumps(colorcommand)) + '\n'
    color_index = color[0]
    leds = [int(led_index)]
    # print (leds,color_index)
    leds.insert(0,color_index)
    text = {"ADDR":addr,"color":[leds]}
    texts += str(json.dumps(text)) + '\n'
    return texts

# 库位灯打开
@app.route('/indledopen',methods=['POST'])
def indledopen():
    ser=SerialCommunication();
    data = request.get_json()
    texts = process_lightindex(data)
    # logging.warning("当前通道1ON_LED:{},当前通道2ON_LED:{}".format(led_lights1,led_lights2))
    print (texts)
    ser.send_data(texts)
    msg = '灯地址:{},已点亮'.format(data['light_led'])
    logging.warning(msg)
    c_dict = {'msg':msg}
    return json.dumps(c_dict)

# 库位灯关闭
@app.route('/indledoff',methods=['POST'])
def indledoff():
    ser=SerialCommunication();
    data = request.get_json()
    texts = process_lightindex(data)
    print (texts)
    ser.send_data(texts)
    msg = '灯地址:{},已关闭'.format(data['light_led'])
    logging.warning(msg)
    c_dict = {'msg':msg}
    return json.dumps(c_dict)

@app.route('/indresetled',methods=['POST'])
def indresetled():
    ser=SerialCommunication();
    try:
        data = {'channel_num':'all','channel_color':'off'}
        texts = process_linetest(data)
        # logging.warning(texts)
        logging.warning("指令：{}".format(texts))
        if isinstance(texts,list):
            for line in texts:
                ser.send_data(line)
                time.sleep(0.1)
        else:
            ser.send_data(texts)
        msg = '灯条已重置'
        logging.warning(msg)
        c_dict = {'msg':msg}
    except Exception as e:
        c_dict = {'msg':'重置失败'}
    return json.dumps(c_dict)

@app.route('/indworkinglight',methods=['POST'])
def indworkinglight():
    ser=SerialCommunication();
    data = request.get_json()
    # channel = data['workchannel']
    text=maincollection(data)
    ser.send_data(text)
    msg = '状态灯"{}"打开指令发送成功'.format(data['workchannel'])
    logging.warning(msg)
    r_json = {'msg':msg}
    return json.dumps(r_json)


@app.route('/indworkingoff',methods=['POST'])
def indworkingoff():
    ser=SerialCommunication();
    data = request.get_json()
    text=maincollection(data)
    ser.send_data(text)
    # res = ser.read_alldata()
    # print (res)
    msg = '状态灯"{}"关闭指令发送成功'.format(data['workchannel'])
    logging.warning(msg)
    r_json = {'msg':msg}
    return json.dumps(r_json)

@app.route('/checkcom',methods=['POST'])
def checkcom():
    ser = SerialCommunication()
    s_state=ser.check_serial()
    c_dict = {'msg':s_state}
    logging.warning(s_state)
    return json.dumps(c_dict)

@app.route('/scancom',methods=['POST'])
def scancom():
    global ser
    ser = SerialCommunication()
    port_list = ser.get_used_port()
    msg = ''
    for index,port in enumerate(port_list):
        logging.warning("串口名称：{}".format(port.name))
        msg += "串口{}:{}/".format(str(index),str(port.name))
    logging.warning(msg)
    r_json = {'msg':msg}
    return json.dumps(r_json)

@app.route('/resetmain',methods=['POST'])
def resetmain():
    ser = SerialCommunication()
    data = request.get_json()
    text=maincollection(data)
    print (text)
    ser.send_data(text)
    logging.warning('reset指令发送成功')
    r_json = {'msg':'reset指令发送成功'}
    return json.dumps(r_json)

@app.route('/powermain',methods=['POST'])
def powermain():
    ser=SerialCommunication();
    data = request.get_json()
    text=maincollection(data)
    print (text)
    ser.send_data(text)
    logging.warning('power指令发送成功')
    r_json = {'msg':'power指令发送成功'}
    return json.dumps(r_json)


def maincollection(data):
    if data['command'] == 'reset':
        maincommand = str(json.dumps({"ADDR":"0","reset":"true"})) + '\n'
    elif data['command'] == 'worklight':
        command_dicts = {
                        "ADDR":"0",
                        "lighton":[int(data['workchannel'])]
        }
        maincommand = str(json.dumps(command_dicts)) + '\n'
        # maincommand = str(json.dumps(colorcommand)) + '\n'
    elif data['command'] == 'workoff':
        command_dicts = {
                        "ADDR":"0",
                        "lightoff":[int(data['workchannel'])]
        }
        maincommand = str(json.dumps(command_dicts)) + '\n'
    elif data['command'] == 'power':
        maincommand = str(json.dumps({"ADDR":"0","power":"true"})) + '\n'
    return maincommand

# 扫描库位测试
def testscan(name):
    global scan_state
    # global state_addr
    # serial_cf = ReadConfig()
    command = ""
    addrs = read_addrs()
    addrs = addrs.split('@')
    for addr in addrs:
        command +=addr + '\n'
        # state_addr.append(addr)
    ser = SerialCommunication()
    while scan_state:
        try:
        # command = "A1\nA2\nA3\nA4\nA5\nA6\nA7\nA8\nA9\nA10\nA11\nA12\nA13\nA14\n"
            print (command)
            start = timeit.default_timer()
            ser.send_data(command)
            location_status=ser.read_alldata()
            print ('----------------------',location_status)
            cur_dict,old_dict = first_filter(location_status)
            show_led,off_led = compare_dict(cur_dict,old_dict)
            print (show_led,off_led)
            if show_led or off_led:
                led_command = scan_show(show_led,off_led)
                for line in led_command:
                    ser.send_data(line)
                    time.sleep(0.03)
            end = timeit.default_timer()
            print (str(end-start))
        except Exception as e:
            logging.warning("库位扫描发生错误：{}".format(e))
            scan_state = False
        time.sleep(0.5)

def compare_dict(cur_dict,old_dict):
    show_led = {}
    off_led = {}
    # print ('-------------old_dict',old_dict)
    # print ('-------------cur_dict',cur_dict)
    # if old_dict:
    for addr,leds in cur_dict.items():
        if len(leds) == 100:
            if old_dict.get(addr,''):
                old_leds=old_dict[addr]
                for i,old in enumerate(old_leds):
                    # sensor = str(i+1) +'@' addr
                    sensor = "{}@{}".format(str(i+1),addr)
                    if convert_dict.get(sensor,''):
                        led_add_loc = convert_dict[sensor]
                        led_index = int(led_add_loc.split('@')[0])
                        if old != leds[i] and old == '0':
                            if show_led.get(addr,''):
                                show_led[addr].append(led_index)
                            else:
                                show_led[addr] = [led_index]
                        elif old != leds[i] and old == '1':
                            if off_led.get(addr,''):
                                off_led[addr].append(led_index)
                            else:
                                off_led[addr] = [led_index]
            old_dict[addr] = leds
        change_deatil(old_dict)
    # else:
    #     print ('未初始化数据')
    return show_led,off_led

def scan_show(show,off):
    # texts = ""
    texts = []
    show_color = COLORS.get('red',[15,255,255,255])[0]
    off_color = COLORS.get('green',[15,255,255,255])[0]
    for addr,show_leds in show.items():
        if off.get(addr,''):
            off_leds = off.get(addr,[])
            off_leds.insert(0,off_color)
            show_leds.insert(0,show_color)
            off.pop(addr)
            addr = addr.split("A")[1]
            command = {"ADDR":addr,"color":[show_leds,off_leds]}
            # texts += str(json.dumps(command)) + '\n'
            texts.append(str(json.dumps(command)) + '\n')
        else:
            addr = addr.split("A")[1]
            show_leds.insert(0,show_color)
            command = {"ADDR":addr,"color":[show_leds]}
            texts.append(str(json.dumps(command)) + '\n')
    if off:
        for addr,off_leds in off.items():
            addr = addr.split("A")[1]
            off_leds.insert(0,off_color)
            command = {"ADDR":addr,"color":[off_leds]}
            texts.append(str(json.dumps(command)) + '\n')
    logging.warning(texts)
    return texts



@app.route('/scantest',methods=['POST'])
def start_scantest():
    global scan_state
    if scan_state == False:
        scan_state = True
        scan = threading.Thread(target=testscan, args=("scan",))
        # control = threading.Thread(target=run, args=("control",))
        scan.start()
        # control.start()
        msg = "库位扫描已开启"
    else:
        msg = "库位扫描中，请勿重复开启"
    logging.warning(msg)
    return json.dumps({'msg':msg})

@app.route('/stopscantest',methods=['POST'])
def stop_scantest():
    global scan_state
    if scan_state == True:
    # control.start()
        scan_state = False
        msg = "库位扫描已关闭"
        reset_value()
        indresetled()
    else:
        msg = "库位扫描未启动，无需关闭"
        reset_value()
    logging.warning(msg)
    return json.dumps({'msg':msg})

def read_test_scan():
    global scan_state
    test_state = scan_state
    return test_state

# 验证测试动作led验证
@app.route('/randomtest',methods=['POST'])
def randomtest():
    test1 = threading.Thread(target=line_led_test)
        # control = threading.Thread(target=run, args=("control",))
    test1.start()
    return json.dumps({'msg':'随机亮灯开启'})

def line_led_test():
    global scan_state
    command = ""
    addrs = read_addrs()
    addrs = addrs.split('@')
    for addr in addrs:
        command +=addr + '\n'
    colors = [1,2,3,4,5,6,7,8,9,10,11,12,13,14]
    while scan_state:
        for addr in addrs:
            leds = [1,100]
            a = choice(colors)
            leds.insert(0,a)
            number = re.findall(r"\d+",addr)[0]
            command = str(json.dumps({"ADDR":number,"ledrange":leds})) + '\n'
            ser.send_data(command)
            print ('------------------------2222',command)
            time.sleep(0.5)