#!/usr/bin/python3.4
# -*- coding: utf-8 -*-
# from typing import List
import asyncio

from jinja2 import Environment, PackageLoader
from flask import Flask
import flask
import os
import sys
import errno
import logging
#import subprocess
from subprocess import Popen,call,PIPE
import shlex
import time
import threading
import json
from collections import namedtuple
import sqlite3

from jinja2 import FileSystemLoader

FileInfo = namedtuple('FileInfo', ['relative_path', 'target_path', 'filename', 'context'], verbose=True)

app = Flask(__name__)
# env = Environment(loader=FileSystemLoader('.'))
# env = Environment(loader=PackageLoader('yourapplication', 'templates'))


script_lock = threading.Lock()

class clientThread(threading.Thread):
    def __init__(self, ssid, passwd):
        threading.Thread.__init__(self)
        self.ssid = ssid
        self.passwd = passwd
    def run(self):
        if not is_associated() :
            run_script('config_client')
        connect_to_network(self.ssid,self.passwd)

class apThread(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
    def run(self):
        configure('config_ap', dict())

class checkUSBThread(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
    def run(self):
        cmd ="su pi -c 'mono /home/pi/yodiwo/wisperFactoryReset/wisperFactoryReset.exe > /home/pi/yodiwo/wisperFactoryReset.log' &"
        run_wpa_cli_cmd(cmd)

class WiFiNet:
     def __init__(self, essid, mac,encryption,authsuites):
         self.essid = essid
         self.mac= mac
         self.encryption = encryption
         self.authsuites = authsuites





@app.route("/")
def hello():
    return "Hello World!"

@app.route("/render")
def render():
    return "Hello World!"

@app.route('/config_client', methods=['GET', 'POST'])
def config_client():
    ssid = flask.request.args.get('config_wifi_ssid')
    password = flask.request.args.get('config_wifi_password')

    if not password:
        password = ""
    if not ssid:
        return "Invalid parameters", 400
    else:
        thread1 = clientThread(ssid,password)
        thread1.start()
        return "Ok"

@app.route('/client_mode', methods=['GET', 'POST'])
def client_mode():
    run_script('config_client')
    return "Ok"

@app.route('/config_ap', methods=['GET', 'POST'])
def config_ap():
    thread1 = apThread()
    thread1.start()
    return "Ok"

   # vars = {
   # }
   # configure('config_ap', vars)

@app.route('/purge_wifi_settings', methods=['GET', 'POST'])
def purge_wifi_settings():
    configure('config_ap', dict(), 1)
    return "Ok"

@app.route('/scan', methods=['GET', 'POST'])
def scan():
    essid_list = []
    j = 0
    cmd = "sudo iwlist wlan0 scan"
    res = run_wpa_cli_cmd(cmd)
    res = res.strip()
    cells= res.decode("utf-8").split('Cell')
    print (cells[1])
    foundessid= False
    foundaddress= False
    foundencryption=False
    foundauthsuites= False;
    authenticationsuites=[]
    cells.pop(0)
    for cell in cells:
        lines= cell.split('\n')
        for line in lines:
            if "ESSID" in line:
                essid = line.strip().split(':')[1]
            elif "Encryption" in line:
                encryption = line.strip().split(':')[1]
            elif "Address" in line:
                address = line.strip().split(': ')[1]
            elif "Authentication Suites" in line:
                auth = line.strip().split(': ')[1]
                authenticationsuites.append(auth)
        print ("Construct wifi net")
        authsuites = ",".join(authenticationsuites)
        wifinet= WiFiNet(essid,address,encryption,authsuites)
        authenticationsuites=[]
        authsuites=''
        essid_list.append(wifinet)
    res_json = json.dumps([ob.__dict__ for ob in essid_list])
    return (res_json)


@app.route('/check_usb')
def check_usb():
    thread1 = checkUSBThread()
    thread1.start()
    return "Ok"

@app.route('/connectinfo',methods=['GET', 'POST'])
def connectinfo():
    try:
        cmd = "sudo iwconfig wlan0"
        res = run_wpa_cli_cmd(cmd)
        print(res)
        #res = res.strip()
        lines = res.decode("utf-8").split('\n')
        for line in lines:
            if ("ESSID" in line):
                essid = line.strip().split('ESSID:')[1]
                return  essid
        return "None"
    except:
        return "Unexpected Error"

@app.route('/reboot')
def reboot():
    cmd = "sudo reboot"
    run_wpa_cli_cmd(cmd)
    return "Ok"

@app.route('/removeflic', methods=['GET', 'POST'])
def removeflic():
    try:
        bdaddr = flask.request.args.get('bdaddr')
        print(bdaddr)
        if bdaddr is None:
            removeallflics()
            res=stopflicd()
            print(res)
            time.sleep(3)
            res=startflicd()
            print(res)
        else:
            removesingleflic(bdaddr)
            res=stopflicd()
            print(res)
            time.sleep(3)
            startflicd()
            print(res)
        return "OK"
    except Exception as e:
        print ("Oops, exception while removing flic buttons")
        print(str(e))
        return "Bad Request"

def stopflicd():
    try:
        print ("Stop Flicd")
        run_wpa_cli_cmd("sudo killall flicd")
        #os.system("sudo killall flicd")
        return "OK"
    except Exception as e:
        print ("Oops, exception while stopping flicd ")
        print(str(e))
        return "Bad Request"

def startflicd():
    try:
        print ("StartFlicd")
        run_wpa_cli_cmd("sudo /home/pi/extools/flic/flicd -d -f /home/pi/extools/flic/flic.sqlite3 -s 0.0.0.0 -l /tmp/log_flicd &")
        #os.system("sudo /home/pi/extools/flic/flicd -d -f /home/pi/extools/flic/flic.sqlite3 -s 0.0.0.0 -l /tmp/log_flicd &")
        return "OK"
    except Exception as e:
        print ("Oops, exception while stopping flicd ")
        print(str(e))
        return "Bad Request"


def removeallflics():
    print("Remove All Flics")
    try:
        conn=sqlite3.connect('/home/pi/extools/flic/flic.sqlite3')
        curs=conn.cursor()
        curs.execute("DELETE FROM buttons")
        conn.commit()
    except Exception as e:
        print (str(e))


def removesingleflic(bdaddr):
    print("Remove Single Flic")
    try:
        conn=sqlite3.connect('/home/pi/extools/flic/flic.sqlite3')
        curs=conn.cursor()
        query = 'DELETE FROM buttons WHERE bdaddr=?'
        curs.execute(query, (bdaddr.strip(),))
        #curs.execute("DELETE FROM buttons WHERE bdaddr='" + bdaddr +"'")
        conn.commit()
    except Exception as e:
        print (str(e))


def configure(context, vars = None, flag = None):
    make_config(context, vars, flag)
    run_script(context)

def make_config(context, vars = None, flag = None):
    file_infos = get_files(context)
    for info in file_infos:
        """
        do nothing with wpa_supplicant.conf
        """
        if info.relative_path == "config_ap/etc/wpa_supplicant" and flag!=1:
            continue
        else:
            # processed = render_file(os.path.join(info.relative_path, info.filename), vars)
            processed = render_file(info.relative_path, info.filename, vars)
            print (info.relative_path)
            with open(os.path.join(info.target_path, info.filename), 'w') as f:
                f.write(processed)


# @asyncio.coroutine
def run_script(context):
    script = os.path.join('.', context + '.sh')
    print (script)
    call([script])
    #Popen([script])
    #t1 = threading.Thread(target=run_script_inner, args=[script])
    #t1.start()

#def run_script_inner(filename):
#    with script_lock:
#        subprocess.call([filename])


def get_files(context):# -> List[FileInfo]:
    dirs = os.walk(context)
    files = []
    for d in dirs:
        targetpath = d[0].split(context, 1)[1]
        new = [FileInfo(d[0], targetpath, f, context) for f in d[2]]
        files.extend(new)
    return files


def render_file(path, filename, vars = None):
    # with open(filename, 'r') as f:
    #     template_string = f.read()
    # template = Environment().from_string(template_string)
    template = Environment(loader=FileSystemLoader(path)).get_template(filename)
    return template.render(**vars)

def run_wpa_cli_cmd(rcmd):
    """
    Runs a program, and it's paramters (e.g. rcmd="ls -lh /var/www")
    Returns output if successful, or None and logs error if not.
    """

    cmd = shlex.split(rcmd)
    executable = cmd[0]
    executable_options=cmd[1:]

    try:
        proc  = Popen(([executable] + executable_options), stdout=PIPE, stderr=PIPE)
        response = proc.communicate()
        response_stdout, response_stderr = response[0], response[1]
    except OSError(e):
        if e.errno == errno.ENOENT:
            logging.debug( "Unable to locate '%s' program. Is it in your path?" % executable )
        else:
            logging.error( "O/S error occured when trying to run '%s': \"%s\"" % (executable, str(e)) )
    except ValueError(e):
        logging.debug( "Value error occured. Check your parameters." )
    else:
        if proc.wait() != 0:
            logging.debug( "Executable '%s' returned with the error: \"%s\"" %(executable,response_stderr) )
            return response
        else:
            logging.debug( "Executable '%s' returned successfully. First line of response was \"%s\"" %(executable, response_stdout.decode("utf-8").split('\n')[0] ))
            return response_stdout

def get_net_number(ssid):
    """
    Returns the number of existing network
    """
    cmd = "wpa_cli -i wlan0 list_net"
    res = run_wpa_cli_cmd(cmd)
    nets = res.decode("utf-8").split('\n')
    print(len(nets))

    for i in range(1, (len(nets)-1)) :
        found = nets[i].count(ssid)
        if found:
            break
    return i


def check_network_exist(ssid):
    """
    Check if a network already exists, in order to avoid duplicate entry
    in wpa_supplicant.conf
    """
    try:
        cmd = "wpa_cli -i wlan0 list_net"
        res = run_wpa_cli_cmd(cmd)
        tmp = res.decode("utf-8").find(ssid)
        if ( tmp == -1 ):
            return tmp
        else:
            net_no = get_net_number(ssid)
            return net_no
    except:
        return -1
'''
For future use in order to implement temporary disable nets
'''
# def check_enabled_net():
#     """
#     Check if active networks exist
#     """
#     try:
#         cmd = "wpa_cli -i wlan0 list_net"
#         res = run_wpa_cli_cmd(cmd)
#         nets = res.decode("utf-8").split('\n')
#         print(len(nets))
#
#         for i in range(1, (len(nets)-1)) :
#             found = nets[i].count("CURRENT")
#             if found:
#                 return i
#     except:
#         return -1

def connect_to_network(ssid, password):

    netw = check_network_exist(ssid)

    if netw == -1 :
        print ("Network is NOT found , add it to conf")
        cmd_add_net = "wpa_cli -i wlan0 add_network"
        res = run_wpa_cli_cmd(cmd_add_net)
        print (cmd_add_net)
        print (res.strip())
        cmd_set_ssid = "wpa_cli -i wlan0 set_network %d ssid \\\"%s\\\"" % (int(res),ssid)
        resp = run_wpa_cli_cmd(cmd_set_ssid)
        print(cmd_set_ssid)
        print(resp.strip())
        if password != "":
            cmd_set_mgmt = "wpa_cli -i wlan0 set_network %d key_mgmt WPA-PSK" % (int(res))
            resp = run_wpa_cli_cmd(cmd_set_mgmt)
            print(cmd_set_mgmt)
            print(resp.strip())
            cmd_set_key = "wpa_cli -i wlan0 set_network %d psk \\\"%s\\\"" % (int(res),password)
            resp = run_wpa_cli_cmd(cmd_set_key)
            print(cmd_set_key)
            print(resp.strip())
        else:
            cmd_set_mgmt = "wpa_cli -i wlan0 set_network %d key_mgmt NONE" % (int(res))
            resp = run_wpa_cli_cmd(cmd_set_mgmt)
            print(cmd_set_mgmt)
            print(resp.strip())
        # active_net = check_enabled_net()
        # if(active_net):
        #     cmd_disable = "wpa_cli -i wlan0 disable_network %d" % (int(active_net)-1)
        #     resp = run_wpa_cli_cmd(cmd_disable)

        cmd_enable = "wpa_cli -i wlan0 enable_network %d" % (int(res))
        resp = run_wpa_cli_cmd(cmd_enable)
        time.sleep(5)
        print (cmd_enable)
        print(resp.strip())
        #cmd_save = "wpa_cli -i wlan0 save_config"
        #resp = run_wpa_cli_cmd(cmd_save)
        #print (cmd_save)
        #print(resp.strip())
    else:

        # active_net = check_enabled_net()
        # if active_net :
        #     cmd_disable = "wpa_cli -i wlan0 disable_network %d" % (int(active_net)-1)
        #     resp = run_wpa_cli_cmd(cmd_disable)
        #     print (cmd_disable)
        #     print(resp.strip())
        cmd_enable = "wpa_cli -i wlan0 enable_network %d" % (int(netw)-1)
        resp = run_wpa_cli_cmd(cmd_enable)
        time.sleep(5)
        print (cmd_enable)
        print(resp.strip())

    #time.sleep(10)
    cnt = 0
    while not is_associated():
         if cnt < 60 :
             time.sleep(1)
             print("*")
             cnt = cnt + 1
         else :
             break
    if cnt == 60 :
        configure('config_ap',dict())
    else :
        cmd_save = "wpa_cli -i wlan0 save_config"
        resp = run_wpa_cli_cmd(cmd_save)
        print (cmd_save)
        print(resp.strip())

    return True


def is_associated():
    """
    Check if we're associated to a network.
    """
    try:
        res = run_wpa_cli_cmd("wpa_cli -i wlan0 status | grep wpa_state")
        #print (res)
        tmp = res.decode("utf-8").find('COMPLETED')
        #tmp = res.strip().decode("utf-8").split('=')[1]
        print(tmp)
        if tmp != -1:
            print ("Connected !!!!!!!!!!!!!!!!!!!!!!!")
            return True
    except:
        return False

if __name__ == "__main__":
    # make_config('config_client', {'config_wifi_ssid': 'asdf', 'config_wifi_password': 'zxcv'})
    # files = get_files('config_ap')

    if len(sys.argv) == 1:
        app.run(host="0.0.0.0", port=8080, debug=True)

    else:
        if 'config_client' in sys.argv[1] and len(sys.argv) >= 4:
            print('configuring client')
            thread1 = clientThread(sys.argv[2],sys.argv[3])
            thread1.start()
            # if not is_associated() :
            #     run_script('config_client')
            # connect_to_network(sys.argv[2],sys.argv[3])
        elif 'config_ap' in sys.argv[1] :
            print('configuring ap')
            configure('config_ap', dict())
        elif 'scan' in sys.argv[1] :
            essid_list = []
            print("Start scanning")
            cmd = "sudo iwlist wlan0 scan"
            res = run_wpa_cli_cmd(cmd)
            resp = res.decode("utf-8").split('\n')
            j = 0
            for i in range(1, len(resp)):
                if "ESSID" in resp[i]:
                    essid_list.insert(j,resp[i].strip().split(':')[1])
                    j = j + 1

            res_json = json.dumps(essid_list)
            print(res_json)

        elif 'purge_wifi_settings' in sys.argv[1] :
            configure('config_ap',dict(),1)