#!/usr/bin/python

from flask import Flask, render_template, jsonify, request
from datetime import datetime
from flask.wrappers import Request
import redis
import os
import json
from werkzeug.utils import redirect
import os.path, time
#from pathlib import Path
#from stat import S_ISREG, ST_CTIME, ST_MODE

#assegno ipv4 statico
ipv4 = '10.74.83.210'

#configurazione per lavorare su server redis locale
REDIS_PORT = 6379
REDIS_HOST = '127.0.0.1'
redSrv0 = redis.Redis(
    host=REDIS_HOST,
    port=REDIS_PORT,
    db=0)

#funzione per leggere e decodificare da redis
def getRedisVal(redisKey):
   return redSrv0.get(redisKey).decode('utf-8')

flaskApp = Flask(__name__)
flaskApp.config['JSON_SORT_KEYS'] = False
@flaskApp.route("/")
#funzione main: passa al template home il titolo
def main():
   channelsData = {
      'title' : 'Home'
      }
   #assegno il template html di riferimento
   return render_template('home.html', **channelsData)

@flaskApp.route("/logger")
#funzione logger, route a pagina /logger
def logger():
   channelsData = {
      'title' : 'Logger',
      'timeSrv' : getRedisVal('RTDATA:TIME:SRV'),
      'timeLog' : getRedisVal('RTDATA:TIME:LOG'),
      'LogFreq' : getRedisVal('SETTINGS:LOG:FREQ'),
      'WriteFreq' : getRedisVal('SETTINGS:WRITE:FREQ'),
      }
   #assegno il template html di riferimento
   return render_template('logger.html', **channelsData)

@flaskApp.route("/settings")
#funzione setup, route a pagina /setup
def setup():
   channelsData = {
      'title' : 'Settings',
      'LogFreq' : getRedisVal('SETTINGS:LOG:FREQ'),
      'WriteFreq' : getRedisVal('SETTINGS:WRITE:FREQ'),
      }
   #assegno il template html di riferimento
   return render_template('settings.html', **channelsData)

@flaskApp.route("/about")
#funzione about, route a pagina /about
def about():
   channelsData = {
      'title' : 'About'
      }
   #assegno il template html di riferimento
   return render_template('about.html', **channelsData)

# definisco una NUOVA route a cui rispondere su chiamta in metodo GET x restituire dati aggiornati
@flaskApp.route("/api/v1/channels/all", methods=['GET'])
def api_channels_all():
   numCh = getRedisVal('SETTINGS:SELECTED_CH')
   #funzione api_channels_all: legge direttamente da redis, ritorna jsonify

   CH = [0,0,0,0,0,0,0,0]
   OUT = [0,0,0,0,0,0,0,0]
   OUTMIN = [0,0,0,0,0,0,0,0]
   OUTMAX = [0,0,0,0,0,0,0,0]
   for numCh in range(0,8,+1):
      CH[numCh] = getRedisVal('RTDATA:CH:'+str(numCh))
      OUT[numCh] = getRedisVal('RTDATA:OUT:'+str(numCh))
      OUTMIN[numCh] = getRedisVal('SETTINGS:OUT:MIN:'+str(numCh))
      OUTMAX[numCh] = getRedisVal('SETTINGS:OUT:MAX:'+str(numCh))

   channelsData = {
      'timeSrv' : getRedisVal('RTDATA:TIME:SRV'),
      'timeLog' : getRedisVal('RTDATA:TIME:LOG'),
      'LogFreq' : getRedisVal('SETTINGS:LOG:FREQ'),
      'WriteFreq' : getRedisVal('SETTINGS:WRITE:FREQ'),
      'Status' : getRedisVal('SETTINGS:LOG:STATUS'),
      'Channels': CH,
      'Outs': OUT,
      'Outmin': OUTMIN,
      'Outmax': OUTMAX,
      'ChA' : getRedisVal('SETTINGS:CHANNEL:A'),
      'ChB' : getRedisVal('SETTINGS:CHANNEL:B'),
      'ChScaleMax' : getRedisVal('SETTINGS:IN:MAX:'+str(numCh)),
      'ChScaleMin' : getRedisVal('SETTINGS:IN:MIN:'+str(numCh)),
      'ChRealMax' : getRedisVal('SETTINGS:OUT:MAX:'+str(numCh)),
      'ChRealMin' : getRedisVal('SETTINGS:OUT:MIN:'+str(numCh)),
      'LastSessionName' : getRedisVal('RTDATA:SESSION:NAME')
      }
   # restituisce in formato json i dati letti da redis
   return jsonify(channelsData)

# definisco una NUOVA route a cui rispondere su chiamta in metodo GET x restituire dati aggiornati
@flaskApp.route("/api/v1/channels/current", methods=['GET'])
def api_channels_current():
   numCh = getRedisVal('SETTINGS:SELECTED_CH')
   #funzione api_channels_all: legge direttamente da redis, ritorna jsonify
   result = {
      'numCh'   : numCh,
      'timeSrv'   : getRedisVal('RTDATA:TIME:SRV'),
      'timeLog'   : getRedisVal('RTDATA:TIME:LOG'),
      'LogFreq'   : getRedisVal('SETTINGS:LOG:FREQ'),
      'WriteFreq' : getRedisVal('SETTINGS:WRITE:FREQ'),
      'CurrIn'    : getRedisVal('RTDATA:CH:'+str(numCh)),
      'CurrOut'   : getRedisVal('RTDATA:OUT:'+str(numCh)),
      'MaxOut' : getRedisVal('SETTINGS:OUT:MAX:'+str(numCh)),
      'MinOut' : getRedisVal('SETTINGS:OUT:MIN:'+str(numCh)),
      'MaxIn'  : getRedisVal('SETTINGS:IN:MAX:'+str(numCh)),
      'MinIn'  : getRedisVal('SETTINGS:IN:MIN:'+str(numCh))
      }
   # restituisce in formato json i dati letti da redis
   return jsonify(result)


# elenco file nella directory
@flaskApp.route("/api/v1/files/list", methods=['GET'])
def api_get_files():
   dataDir='/home/pi/data/'
   fileList = os.listdir(dataDir)
   # #all entries in the directory w/ stats
   # data = (os.path.join(dataDir, fn) for fn in os.listdir(dataDir))
   # data = ((os.stat(path), path) for path in data)
   # # regular files, insert creation date
   # data = ((stat[ST_CTIME], path)
   #          for stat, path in data if S_ISREG(stat[ST_MODE]))

   lista = []
   idx=0
   # for item in sorted(data):
   for item in fileList:
      t_obj = time.strptime(time.ctime(os.path.getctime(dataDir+item)))
      # Transforming the time object to a timestamp 
      # of ISO 8601 format
      T_stamp = time.strftime("%Y-%m-%d %H:%M:%S", t_obj)
      current = {"name": item,"size": os.path.getsize(dataDir+item), "date":T_stamp}
      # current = {"name": item,"size": os.path.getsize(dataDir+item), "date":time.ctime(os.path.getctime(dataDir+item))}
      lista.append(current)
      idx=idx+1
   return jsonify(fileTable = lista)

# Route di comando x LOG: start e stop
@flaskApp.route("/api/v1/log/start", methods=['PUT'])
def start_log():
   #funzione start_log: scrive su redis LOG:STATUS -> 1
   redSrv0.set('SETTINGS:LOG:STATUS', 1)
   #data e time ora
   lastDate = datetime.now()
   #formato per data time nomefile: YYYYddmm_HMS
   format = "%Y%m%d_%H%M%S"
   #format date e time adando strftime()
   nameDate = lastDate.strftime(format) + ".csv"
   redSrv0.set('RTDATA:SESSION:NAME', nameDate)
   return "OK"

@flaskApp.route("/api/v1/log/stop", methods=['PUT'])
def stop_log():
   #funzione stop_log: scrive su redis LOG:STATUS -> 0
   redSrv0.set('SETTINGS:LOG:STATUS', 0)
   redSrv0.set('RTDATA:SESSION:NAME', "-")
   return "OK"

@flaskApp.route("/api/v1/setup/saveInMin", methods=['PUT'])
def setupInMin():
   # devo leggere il channel attualmente selezionato
   indCh =  getRedisVal('SETTINGS:SELECTED_CH')
   currChVal = redSrv0.get('RTDATA:CH:'+ str(indCh))
   redSrv0.set('SETTINGS:IN:MIN:'+ str(indCh), currChVal)
   return redirect("/settings")

@flaskApp.route("/api/v1/setup/saveInMax", methods=['PUT'])
def setupInMax():
   # devo leggere il channel attualmente selezionato
   indCh =  getRedisVal('SETTINGS:SELECTED_CH')
   currChVal = redSrv0.get('RTDATA:CH:'+ str(indCh))
   redSrv0.set('SETTINGS:IN:MAX:'+ str(indCh), currChVal)
   return redirect("/settings")

@flaskApp.route("/api/v1/setup/selectChannelA/<numChA>", methods=['PUT'])
def selectChannelA(numChA):
   print(numChA)
   redSrv0.set('SETTINGS:CHANNEL:A', numChA)
   return "OK"

@flaskApp.route("/api/v1/setup/selectChannelB/<numChB>", methods=['PUT'])
def selectChannelB(numChB):
   print(numChB)
   redSrv0.set('SETTINGS:CHANNEL:B', numChB)
   return "OK"

@flaskApp.route("/api/v1/setup/selectChannel/<numCh>", methods=['PUT'])
def setChannel(numCh):
   print(numCh)
   redSrv0.set('SETTINGS:SELECTED_CH', numCh)
   return "OK"

@flaskApp.route("/api/v1/frequency", methods=['POST'])
def setWriteFrequency():
   #funzione set frequenza scrive su redis LOG:FREQ prendendolo dall'input in pagina html con nome LogFreq
   newWriteFrequency = request.form['WriteFreq']
   redSrv0.set('SETTINGS:WRITE:FREQ', newWriteFrequency)
   #funzione set frequenza scrive su redis LOG:FREQ prendendolo dall'input in pagina html con nome LogFreq
   newLogFrequency = request.form['LogFreq']
   redSrv0.set('SETTINGS:LOG:FREQ', newLogFrequency)
   # rimando in settings
   return redirect("/settings")

@flaskApp.route("/api/v1/scaleout", methods=['POST'])
def setScale():
   indexCh =  getRedisVal('SETTINGS:SELECTED_CH')
   scaleMin = request.form['MinOut']
   redSrv0.set('SETTINGS:OUT:MIN:'+ str(indexCh), scaleMin)
   scaleMax = request.form['MaxOut']
   redSrv0.set('SETTINGS:OUT:MAX:'+ str(indexCh), scaleMax)
   # rimando in settings
   return redirect("/settings")

@flaskApp.route("/api/v1/setup/resetSettings", methods=['POST'])
def resetSetup():
   #resetto i campi di redis alla situazione di partenza
   redSrv0.set('SETTINGS:LOG:FREQ',250)
   redSrv0.set('SETTINGS:WRITE:FREQ',1000)
   redSrv0.set('SETTINGS:LOG:STATUS',0)
   redSrv0.set('SETTINGS:SELECTED_CH',0)
   for numCh in range(0,8,+1):
      redSrv0.set('SETTINGS:IN:MAX:'+str(numCh),100)
      redSrv0.set('SETTINGS:IN:MIN:'+str(numCh),0)
      redSrv0.set('SETTINGS:OUT:MAX:'+str(numCh),100)
      redSrv0.set('SETTINGS:OUT:MIN:'+str(numCh),0)
   # rimando in settings
   return redirect("/settings")

#dichiaro host ipv4 (ottenuto sopra utilizzando il modulo socket)
if __name__ == "__main__":
   flaskApp.run(host=ipv4, port=80, debug=True)