"""
  Created on Thu Jan 11 15:22:56 2018
  @author: Robin Cavalieri 
  IMA5SC - PFE 2018
  P32 - Détection automatique de DoS sur réseau LoRa
  Main - prédictions, affichage, vérification du trafic 
  """
  ###############################################################################
  #LIBRAIRIES UTILES
  ###############################################################################
  import tkinter as tkr;
  import time;

  import serial;

  import pandas as pd
  # Réseau de neurones 
  from keras.models import Sequential
  from keras.layers import Dense
  from keras.models import model_from_json

  ###############################################################################
  

  ###############################################################################
  #VARIABLES GLOBALES
  ###############################################################################

  ping_mesured=0; 
  rssi_mesured=0;

  result=0;

  puissance_read = 0;
  temp_read = 0;
  trame_read = [];
  state_ok = 'Stable';
  state_attack = 'Perturbé';
  pred = 1;

  ###############################################################################

  ##############################################################################
  #DEFINITION DE LA LECTURE DE PORT 
  ##############################################################################
  ser = serial.Serial(      
   #Pour Linux
   #port='/dev/ttyACM0',
   #Pour Windows
   port='COM4',
   #Vitesse de communication
   baudrate = 9600,
   #Parité 
   parity=serial.PARITY_NONE,
   #Bit de stop
   stopbits=serial.STOPBITS_ONE,
   #Taille du message 
   bytesize=serial.EIGHTBITS,
   #Out
   timeout=1
  )
  counter=0;
  ##############################################################################

  ###############################################################################
  #FONCTIONS UTILES
  ###############################################################################

  def Draw_info():   

      #FRAME INFORMATIONS
      infos=tkr.Frame(root,width=1000,height=5000,relief='groove',background='white',bd=3);
      infos.place(x=10,y=10);  
      #DATE - HEURE
      global text;

      text=tkr.Label(infos,text='Contrôle du trafic LoRa\n\n');

      text.config(font=('arial', 20, 'bold'));
      text.config(bg='white', fg='black');
      text.pack();

      global temperature;
      temperature=tkr.Label(infos,text='\n\nTempérature (°C) : '+ str(temp_read));
      temperature.config(font=('arial', 20, 'bold'));
      temperature.config(bg='white', fg='black');
      temperature.pack();

      global ping;

      ping=tkr.Label(infos,text='\n\nPING(ms) : '+ str(ping_mesured));

      ping.config(font=('arial', 20, 'bold'));
      ping.config(bg='white', fg='black');
      ping.pack();
      global rssi;

      rssi=tkr.Label(infos,text='\n\nRSSI(dBm) : '+ str(puissance_read));

      rssi.config(font=('arial', 20, 'bold'));
      rssi.config(bg='white', fg='black');
      rssi.pack();
      global trame;

      trame=tkr.Label(infos,text='\n\nTrame : '+ "".join(map(chr, trame_read)));

      trame.config(font=('arial', 20, 'bold'));
      trame.config(bg='white', fg='black');

      trame.pack(); 
      global etat;
      etat=tkr.Label(infos,text='\n\nEtat du trafic : '+ state_ok);
      etat.config(font=('arial', 20, 'bold'));
      etat.config(bg='white', fg='black');
      etat.pack();

  ###############################################################################
  #FONCTION DE PREDICTION APPELEE DANS LE MAIN 
  ###############################################################################
  def predictions(data_eval):
      ###########################################################################
      #ARCHITECTURE DU RESEAU DE NEURONES par le biais de la librairie KERAS
      #ANN 
      ###########################################################################
      #Création du classifieur 
      classifier = Sequential();
      #Couche d'entrée donc avec 2 entrées, PING et DELTA_RSSI
      classifier.add(Dense(input_dim = 2, output_dim = 3, init = 'uniform', activation = 'sigmoid'));
      #Couche cachée
      classifier.add(Dense(output_dim = 3, init = 'uniform', activation = 'sigmoid'));
      #Sortie du réseau de neurones 
      classifier.add(Dense(output_dim = 1, init = 'uniform', activation = 'sigmoid'));
      ###########################################################################
      #LOAD DU TRAINING SET
      ###########################################################################
      json_file=open('C:/Users/Utilisateur/PFE/python/Training/training.json','r');
      loaded_model_json=json_file.read();
      json_file.close();
      loaded_model=model_from_json(loaded_model_json);
      loaded_model.load_weights('C:/Users/Utilisateur/PFE/python/Training/training.h5');
      ###########################################################################
      #REALISER DES PREDICTIONS
      ###########################################################################
      #Normalisation des données 
      #sc = StandardScaler();
      predictions = classifier.predict(data_eval);
      return predictions;
  ###############################################################################

      
  def Refresher():

      #VARIABLES GLOBALES
      global cpt_trame;

      global text;

      global temp;
      global temperature;
      global ping;
      global rssi;
      global trame;
      global etat;
      #RECUPERATION DES DONNEES

      text.configure(text=time.asctime());

      x = ser.readline();
      if(0x46 in x and cpt_trame == 0):
          cpt_trame = cpt_trame + 1;
          temp = time.time();
      if(0x46 in x and cpt_trame >= 1):
          t2 = time.time();
          ping_mesured = (t2-temp)*1000;
          temp = t2;
          cpt_trame = cpt_trame + 1;
          #Lecture de la trame 
          trame_read = x;
          #Récupération de la température
          temp_read = (trame_read[11]-48)*10 + trame_read[12]-48;
          #Récupération de la puissance 
          x = ser.readline();
          puissance_read = (x[1]-48)*10 + x[2]-48;
      #REFRESH DES DONNEES   
      temperature.configure(text='\n\nTempérature (°C) : '+ str(temp_read));
      ping.configure(text='\n\nPING(ms) : '+ str(ping_mesured));
      rssi.configure(text='\n\nRSSI(dBm) : '+ str(puissance_read));
      trame.configure(text='\n\nTrame : '+ "".join(map(chr, trame_read)));
      #PREDICTION
      data_to_pred = pd.read_csv('C:/Users/Utilisateur/PFE/python/datasets/data_to_pred.csv');
      pred = predictions(data_to_pred);
      if(pred==0):
          etat.configure(text='\n\nEtat du trafic : '+ state_ok);
      elif(pred==1):
          etat.configure(text='\n\nEtat du trafic : '+ state_attack);

      root.after(1000, Refresher);#Refresh toutes les secondes
  

  ###############################################################################
  #AFFICHAGE
  ###############################################################################

  root=tkr.Tk();

  Draw_info();

  Refresher();
  root.mainloop();
  ###############################################################################