# codinf:utf-8
from flask import render_template, Response, request,redirect,url_for
from werkzeug.utils import secure_filename
from app import app
import json
import time
import pexpect
import neopixel
import os
import requests
import threading
import re
import csv
from time import sleep
from config import Config
from rpi_ws281x import Adafruit_NeoPixel, Color,PixelStrip
import RPi.GPIO as GPIO
from app.led_strip import get_strip
from app.routes import config_dict,SET_CHANNEL,SET_LED_CHANNEL
from app import driver_gpio
import logging
import random

basepath = os.path.dirname(__file__)
statusgreenA = False
statusgreenB = False
post_leds = {'1':{},'2':{}}
strips = {}
ip_config = {'post':'wait'}
try:
    uploads_path = basepath + Config.STATE_PATH
    with open(uploads_path + 'ipconfig.csv','r') as f:
        reader = csv.reader(f)
        current = [row for row in reader]
        ip_config['ip'] = current[0][0]
        ip_config['cid'] = current[0][1]
        logging.warning("ip&cid...:{}".format(ip_config))
except Exception as e:
    logging.warning("ip,cid未配置")


def confirm_state(state):
    uploads_path = basepath + Config.STATE_PATH
    with open(uploads_path + "state.txt","w") as f:
        f.write(state)
def read_state():
    uploads_path = basepath + Config.STATE_PATH
    with open(uploads_path + "state.txt","r") as f:
        state=f.readline()
    return state

def read_version():
    uploads_path = basepath + Config.STATE_PATH
    with open(uploads_path + "version.txt","r") as f:
        s_version=f.readline()
    return s_version

def confirm_ip(data):
    uploads_path = basepath + Config.STATE_PATH
    sipconfig = read_ip()
    with open(uploads_path + 'ipconfig.csv','w') as f:
        if data['ip'] and not data['cid']:
            data['cid'] = sipconfig[0][1]
        elif data['cid'] and not data['ip']:
            data['ip'] = sipconfig[0][0]
        fieldnames = ['ip', 'cid']
        writer = csv.DictWriter(f,fieldnames=fieldnames)
        writer.writerow(data)
    ip_config['ip'] = data['ip']
    ip_config['cid'] = data['cid']
    confirm_autostart()


def confirm_autostart():
    server_add = ip_config['ip'] + '/accshelf/' + ip_config['cid']
    line1 = "Comment = star chrome and enter the website for \"{}\"".format(server_add)
    line2 = "Exec = chromium-browser -kiosk \"{}\"".format(server_add)
    strs=["[Desktop Entry]","Name = Chrome Autostar","Type = Application"]
    strs.append(line1)
    strs.append(line2)
    filename = "/home/pi/.config/autostart/auto.desktop"
    if os.path.isfile(filename):
        os.remove(filename)
        os.mknod(filename)
        cmd = "chmod 777 " + filename
        run = pexpect.spawn('su -c "%s" root' %cmd)
        time.sleep(0.5)
        run.sendline('xxx')   
        time.sleep(0.1)     
        with open("/home/pi/.config/autostart/auto.desktop","a") as f:
            for i in strs:
                f.write("{}\n".format(i))
            f.close()
    else:
        os.mknod(filename)
        cmd = "chmod 777 " + filename
        run = pexpect.spawn('su -c "%s" root' %cmd)
        time.sleep(0.5)
        run.sendline('xxx')   
        time.sleep(0.1)     
        with open("/home/pi/.config/autostart/auto.desktop","a") as f:
            for i in strs:
                f.write("{}\n".format(i))
            f.close()
    logging.warning("自启动脚本更新成功")

def read_ip():
    uploads_path = basepath + Config.STATE_PATH
    with open(uploads_path + 'ipconfig.csv','r') as f:
        reader = csv.reader(f)
        sipconfig = [row for row in reader]
    return sipconfig

def post(seq):
    headers = {'content-type': "application/json"} #请求头信息
    url = ip_config['ip'] + '/service/store/communication'
    cid = ip_config['cid']
    body = {"boxStatus":{"1":{"boxId":1,"status":1,"msg":None,"temperature":None,"humidity":None,"data":{}}},"alarmList":[],"cid":cid,"seq":seq,"op":0,"data":{},"status":1,"msg":None}
    try:
        response = requests.post(url, data = json.dumps(body),headers = headers,timeout=2)
        # response = requests.post("http://jsonplaceholder.typicode.com/posts", data = "some dummy content")
        ele_json = response.json()
        ip_config['post'] = 'success'
        resolve_data(ele_json)
        if ele_json['data']:
            logging.warning("服务器发送数据:{}".format(ele_json['data']))
    except Exception as e:
        ip_config['post'] = 'failed'
        logging.warning("请求服务器失败:{}".format(e))


def process_open_post(single,channel,led_index):
    global post_leds
    if channel == '1' or channel == '2':
        if len(single) == 1:
            post_leds[channel][led_index] = Config.DEFAULT_COLOR
            logging.warning("库位灯开启：{},灯索引：{},颜色：red".format(single[0],led_index))
        elif len(single) == 2:
            post_leds[channel][led_index] = single[1]
            logging.warning("库位灯开启：{},灯索引：{},颜色：{}".format(single[0],led_index,single[1]))
        else:
            post_leds[channel][led_index] = single[1] + '@blink'
            logging.warning("库位灯开启闪烁：{},灯索引：{},颜色：{}".format(single[0],led_index,single[1]))
    else:
        for key in post_leds.keys():
            if len(single) == 1:
                post_leds[key][led_index] = Config.DEFAULT_COLOR
                # logging.warning("库位灯开启(双面)：{},灯索引：{},颜色：red".format(single[0],led_index))
            elif len(single) == 2:
                post_leds[key][led_index] = single[1]
                # logging.warning("库位灯开启(双面)：{},灯索引：{},颜色：{}".format(single[0],led_index,single[1]))
            else:
                post_leds[key][led_index] = single[1] + '@blink'
                # logging.warning("库位灯开启(双面)：{},灯索引：{},颜色：{}".format(single[0],led_index,single[1]))
        logging.warning("库位灯开启(双面)：{},灯索引：{}".format(single[0],led_index))

def process_off_post(single,channel,led_index):
    global post_leds
    global strips
    if channel == '1' or channel == '2':
        post_leds[channel].pop(led_index, None)
        strip = strips[channel]
        c_index=list(map(int,re.split(';',led_index)))
        for on_led in c_index:
            strip.setPixelColor(on_led, setcolor('off'))
        # strip.setPixelColor()
        logging.warning("库位灯关闭：{},灯索引：{}".format(single[0],led_index))
    else:
        for key in post_leds.keys():
            post_leds[key].pop(led_index, None)
            strip = strips[key]
            c_index=list(map(int,re.split(';',led_index)))
            for on_led in c_index:
                strip.setPixelColor(on_led, setcolor('off'))
            # strip.setPixelColor()
        logging.warning("库位灯关闭：{},灯索引：{}".format(single[0],led_index))

def process_closeall_post():
    global post_leds
    global strips
    for channel,strip in strips.items():
        colorWipe(strip,Color(0,0,0))
    for key in post_leds.keys():
        post_leds[key] = {}


def resolve_data(datajson):
    global post_leds
    operation=datajson['data']
    # operation = {'open':'1_1_1=red|1_1_2=blue|1_1_3=red|2_1_1=green'}
    channels = []
    if operation:
        if 'open' in operation.keys():
            openstock=operation['open'].split("|")
            for stock in openstock:
                single=stock.split("=")
                print (single)
                if config_dict.get(single[0]):
                    channel = config_dict.get(single[0]).split('@')[1]
                    led_index = config_dict.get(single[0]).split('@')[0]
                    process_open_post(single,channel,led_index)
                    if channel != '3':
                        channels.append(channel)
                    else:
                        channels += ['1','2']
                else:
                    logging.warning("未找到库位：{}".format(config_dict.get(single[0])))
            logging.warning("库位灯有open指令")
        if 'close' in operation.keys():
            offstock = operation['close'].split("|")
            for stock in offstock:
                single = stock.split("=")
                if config_dict.get(single[0]):
                    channel = config_dict.get(single[0]).split('@')[1]
                    led_index = config_dict.get(single[0]).split('@')[0]
                    process_off_post(single,channel,led_index)
                    if channel != '3':
                        channels.append(channel)
                    else:
                        channels += ['1','2']
                else:
                    logging.warning("未找到库位：{}".format(config_dict.get(single[0])))
            logging.warning("库位灯有关闭指令")
        if 'closeAll' in operation.keys():
            process_closeall_post()
            # for k in post_leds.keys():
            #     if k not in channels:
            #         channels.append(k)
            logging.warning("所有库位灯关闭")
    if channels:
        channels = set(channels)
        light_led(channels)

def light_led(channels,wait=50):
    global strips
    for channel in channels:
        strip = strips[channel]
        current_leds = post_leds[channel]
        logging.warning("通道：{},当前开启：{}".format(channel,current_leds))
        for key,value in current_leds.items():
            c_index=list(map(int,re.split(';',key)))
            for on_led in c_index:
                strip.setPixelColor(on_led, setcolor(value))
        strip.show()
        time.sleep(wait/1000)


@app.route('/startpost',methods=['POST'])
def startpost():
    global is_start
    state = read_state()
    if state == 'off':
        confirm_state('on')
        is_start = True
        threads = []
        threads.append(threading.Thread(target=serverpost))
        for t in threads:
            t.start()
        msg = '启动成功'
        current_state = 'on'
        logging.warning("启动成功")
    else:
        msg = '正在运行状态'
        current_state = 'on'
        logging.warning("料架运行中无需重复启动")
    info = []
    c_dict = {'state':current_state,'msg':msg}
    info.append(c_dict)
    return json.dumps(info)



@app.route('/stoppost',methods=['POST'])
def stoppost():
    global is_start
    state = read_state()
    if state == 'on':
        confirm_state('off')
        is_start=False
        # status_light('off')
        reset_strip()
        ip_config['post'] = 'wait'
        logging.warning("关闭成功")
        msg = '关闭成功'
        current_state = 'off'
    else:
        msg = '无需关闭'
        current_state = 'off'
        logging.warning("无需关闭")
    info = []
    c_dict = {'state':current_state,'msg':msg}
    info.append(c_dict)
    return json.dumps(info)

def serverpost():
    global is_start
    global post_leds
    global strips
    start_show()
    # 初始化灯条
    for key,value in SET_LED_CHANNEL.items():
        strips[key] = get_strip(value)
    seq = 1
    while is_start:
        try:
            post(seq)
            check_leds()
            seq+=1
            time.sleep(1)
        except Exception as e:
            logging.warning("执行错误：{}".format(e))

def check_leds():
    global post_leds
    global statusgreenA
    global statusgreenB
    for channel,leds in post_leds.items():
        if leds:
            if channel == '1' and not statusgreenA:
                statusgreenA = True
                driver_gpio.init(SET_CHANNEL['yellowA'])
                driver_gpio.gpio_high(SET_CHANNEL['yellowA'])
                # t = threading.Thread(target=deal_with_greenA)
                # t.start()
                logging.warning("A面黄状态灯开启")
            elif channel == '2' and not statusgreenB:
                statusgreenB = True
                # t = threading.Thread(target=deal_with_greenB)
                # t.start()
                driver_gpio.init(SET_CHANNEL['yellowB'])
                driver_gpio.gpio_high(SET_CHANNEL['yellowB'])
                logging.warning("B面黄状态灯开启")
        else:
            if channel == '1' and statusgreenA:
                statusgreenA = False
                driver_gpio.init(SET_CHANNEL['yellowA'])
                driver_gpio.gpio_low(SET_CHANNEL['yellowA'])
                logging.warning("A面黄状态灯关闭")
            elif channel == '2' and statusgreenB:
                statusgreenB = False
                driver_gpio.init(SET_CHANNEL['yellowB'])
                driver_gpio.gpio_low(SET_CHANNEL['yellowB'])
                logging.warning("B面黄状态灯关闭")


# def deal_with_greenA():
#     global statusgreenA
#     driver_gpio.init(SET_CHANNEL['redA'])
#     while statusgreenA:
#         driver_gpio.gpio_high(SET_CHANNEL['redA'])

# def deal_with_greenB():
#     global statusgreenB
#     driver_gpio.init(SET_CHANNEL['redB'])
#     while statusgreenB:
#         driver_gpio.gpio_high(SET_CHANNEL['redB'])

def start_show(wait=10):
    global post_leds
    pin1,pin2 = SET_LED_CHANNEL['1'],SET_LED_CHANNEL['2']
    strip1 = get_strip(pin1)
    colorWipe(strip1,Color(255,0,0))
    time.sleep(1)
    colorWipe(strip1,Color(0,255,0))
    time.sleep(1)
    colorWipe(strip1,Color(0,0,255))
    time.sleep(1)
    colorWipe(strip1,Color(0,0,0))
    time.sleep(1)
    strip2 = get_strip(pin2)
    colorWipe(strip2,Color(255,0,0))
    time.sleep(1)
    colorWipe(strip2,Color(0,255,0))
    time.sleep(1)
    colorWipe(strip2,Color(0,0,255))
    time.sleep(1)
    colorWipe(strip2,Color(0,0,0))
    time.sleep(1)
    driver_gpio.init(SET_CHANNEL['greenA'])
    driver_gpio.init(SET_CHANNEL['greenB'])
    driver_gpio.gpio_high(SET_CHANNEL['greenA'])
    driver_gpio.gpio_high(SET_CHANNEL['greenB'])



@app.route('/getstate',methods=['POST'])
def getstate():
    current_state = read_state()
    state_info = []
    version = read_version()
    c_dict = {'state':current_state,'msg':'未进行测试动作','ipconfig':ip_config,'version':version}
    state_info.append(c_dict)
    return json.dumps(state_info)

@app.route('/taillog',methods=['POST'])
def taillog():
    a=os.popen("tail -n 20 /prog/smartshelf/logs/smart.log").readlines()
    s = '<br>'
    p = s.join(a)
    poststate = ip_config['post']
    jsondata = {'msg':p,'poststate':poststate}
    return json.dumps(jsondata)

@app.route('/updateip',methods=['POST'])
def updateip():
    data = request.get_json()
    confirm_ip(data)
    logging.warning("ip&cid:{}".format(ip_config))
    ip_info = []
    ip_info.append(ip_config)
    return json.dumps(ip_info)

def colorWipe(strip, color):
    """一次擦除显示像素的颜色."""
    for i in range(strip.numPixels()):
        strip.setPixelColor(i, color)
    strip.show()

def reset_strip():
    global post_leds
    for channel,strip in strips.items():
        colorWipe(strip,Color(255,255,0))
        time.sleep(1)
        colorWipe(strip,Color(0,0,0))
        post_leds[channel] = {}
        time.sleep(1)
    check_leds()


def setcolor(color):
    color = color.lower()
    if color == 'red':
        return Color(0,255,0)
    elif color == 'green':
        return Color(255,0,0)
    elif color == 'yellow':
        return Color(255,255,0)
    elif color == 'off':
        return Color(0,0,0)
    elif color == 'blue':
        return Color(0,0,255)
    else:
        return Color(0,255,255)

            

# 开机启动请求服务器动作
state = read_state()
if state == 'off':
    confirm_state('on')
is_start = True
threads = []
# threads.append(threading.Thread(target=light_led1))
threads.append(threading.Thread(target=serverpost))
for t in threads:
    t.start()
logging.warning("启动成功")