"""
  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 avec méthode des KPPV
  """
  ###############################################################################
  #LIBRAIRIES UTILES
  ###############################################################################
  import time;
  import serial;
  import numpy as np;
  import pandas as pd;
  ###############################################################################
  

  ###############################################################################
  #VARIABLES MESUREES
  ###############################################################################
  ping_mesured=0; 
  rssi_mesured=0;
  result=0;
  puissance_read = 0;
  temp_read = 0;
  trame_read = [];
  ###############################################################################
  

  ##############################################################################
  #DEFINITION DE LA LECTURE DE PORT 
  ##############################################################################
  ser = serial.Serial(      
   #Pour Linux
   #port='/dev/ttyACM0',
   #Pour Windows
   port='COM4',

   #Vitesse4de 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;
  ##############################################################################
  
  ###############################################################################
  #TRAVAIL PRELIMINAIRE DE TRAITEMENT DES DONNEES D'APPRENTISSAGE
  ###############################################################################
  # Ouverture des bases d'apprentissage
  dataset_ping_norm = pd.read_csv('C:/Users/Utilisateur/PFE/python/datasets/ping_norm.csv');
  dataset_ping_attack = pd.read_csv('C:/Users/Utilisateur/PFE/python/datasets/ping_attack.csv');
  dataset_rssi_norm = pd.read_csv('C:/Users/Utilisateur/PFE/python/datasets/rssi_norm.csv');
  dataset_rssi_attack = pd.read_csv('C:/Users/Utilisateur/PFE/python/datasets/rssi_attack.csv');
  
  #Concatenation pour avoir une base de ping et une base de rssi
  dataset_ping = np.concatenate((dataset_ping_attack, dataset_ping_norm), axis=0);
  dataset_rssi = np.concatenate((dataset_rssi_attack, dataset_rssi_norm), axis=0);
  
  #Récupération des tailles de matrices
  [X_ping, Y_ping] = np.shape(dataset_ping);
  [X_rssi, Y_rssi] = np.shape(dataset_rssi);
  ###############################################################################
  
  ###############################################################################
  #KPPV PING
  ###############################################################################
  def prediction_ping(ping):

      cpt = 0;
      k = 5;

      dataset_ping_temp = np.zeros((X_ping,1));

      #Remplissage des distances euclidiennes 

      for i in range(0, X_ping):
          dataset_ping_temp[i,0] = ((dataset_ping[i,1]-ping)**2)**0.5;   

      #Concatenation avec distances euclidiennes 
      dataset_ping_temp = np.c_[dataset_ping, dataset_ping_temp];
      #Tri

      dataset_ping_temp = dataset_ping_temp[dataset_ping_temp[:,2].argsort()]

      #Checking des k premiers voisins

      for j in range(0, k-1): 

          if(dataset_ping_temp[j,0]==1):
              cpt = cpt+1;       

      if(cpt >= (k/2)+1):
          return 1; #Attaque
      else:
          return 0; #RAS

  ###############################################################################
  
  ###############################################################################
  #KPPV RSSI
  ###############################################################################
  def prediction_rssi(rssi):
      cpt = 0;

      k = 20;

      dataset_rssi_temp = np.zeros((X_rssi,1));
      #Remplissage des distances euclidiennes 
      for i in range(0, X_rssi):
          dataset_rssi_temp[i,0] = ((dataset_rssi[i,1]-rssi)**2)**0.5;   
      #Concatenation avec distances euclidiennes 
      dataset_rssi_temp = np.c_[dataset_rssi, dataset_rssi_temp];
      #Tri
      dataset_rssi_temp = dataset_rssi_temp[dataset_rssi_temp[:,2].argsort()]
      #Checking des k premiers voisins
      for j in range(0, k-1): 
          if(dataset_rssi_temp[j,0]==1):
              cpt = cpt+1;       
      if(cpt >= (k/2)+1):
          return 1; #Attaque
      else:
          return 0; #RAS
  ###############################################################################
  

  ###############################################################################
  #AFFICHAGE 
  ###############################################################################  
  def Recorder():
      global temp;
      global temp_read;
      global ping_mesured;
      global puissance_read;
      global trame_read;
      global cpt_trames;

      global cpt_trames_temp;  
      cpt_trames = 0;
      cpt_trames_temp = 0;

      temp = 0;
      #REMISE A 0 DES FICHIERS
      temp_file = open('C:/xampp/htdocs/temperature.csv', 'w')
      ping_file = open('C:/xampp/htdocs/ping.csv', 'w')
      puissance_file = open('C:/xampp/htdocs/puissance.csv', 'w')
      import csv

      while(1):
          #RECUPERATION DES DONNEES
          x = ser.readline();
          

          #FICHIERS CSV APPLICATION WEB
          temp_file = open('C:/xampp/htdocs/temperature.csv', 'a')
          tempwriter = csv.writer(temp_file, delimiter=',');
          
          ping_file = open('C:/xampp/htdocs/ping.csv', 'a')
          pingwriter = csv.writer(ping_file, delimiter=',');
          
          puissance_file = open('C:/xampp/htdocs/puissance.csv', 'a')
          puissancewriter = csv.writer(puissance_file, delimiter=',');
          

          traficping_file = open('C:/xampp/htdocs/traficPing.csv', 'w')
          traficpingwriter = csv.writer(traficping_file);
          
          traficrssi_file = open('C:/xampp/htdocs/traficRssi.csv', 'w')
          traficrssiwriter = csv.writer(traficrssi_file);
          

          if(0x7C in x):
              #Lecture de la trame 
              trame_read = x;         
              #Récupération du compteur de trames
              cpt_trames = (trame_read[15]-48)*100 + (trame_read[16]-48)*10 + (trame_read[17]-48);

              if(0x7C in x and cpt_trames == 1):
                  temp = time.time();
                  
              if(0x7C in x and cpt_trames > 1):
                  t2 = time.time();
                  ping_mesured = (t2-temp)*1000;
                  #Récupération de la température
                  temp_read = (trame_read[12]-48)*10 + trame_read[13]-48;
                  #Récupération de la puissance 
                  x = ser.readline();
                  puissance_read = (x[1]-48)*10 + x[2]-48;
                  #T2 
                  temp = t2;
              
              if(cpt_trames_temp + 1 == cpt_trames):
                  #BOOLEEN
                  state_ping = prediction_ping(ping_mesured);
                  state_rssi = prediction_rssi(puissance_read);
                  #AFFICHAGE
                  print("\n###############################\n");
                  print("TRAME : "+ "".join(map(chr, trame_read))+"\n");
                  print("TRAME NUM. : "+str(cpt_trames)+"\n");
                  print("TEMPERATURE : "+str(temp_read)+" °C\n");
                  print("PUISSANCE : "+str(puissance_read)+" dBm\n");
                  print("PING : "+str(ping_mesured)+" ms\n");
                  if(state_ping == 0):
                      print("PING NORMAL\n");

                      traficpingwriter.writerow([0])

                  elif(state_ping == 1):
                      print("PING ATTAQUE\n");

                      traficpingwriter.writerow([1])

                  if(state_rssi == 0):
                      print("RSSI NORMAL\n");

                      traficrssiwriter.writerow([0])

                  elif(state_rssi == 1):
                      print("RSSI ATTAQUE\n");

                      traficrssiwriter.writerow([1])

                  print("###############################\n");
                  ##########################################
                  #ECRITURE DANS FICHIERS
                  ##########################################
                  tempwriter.writerow([time.time(),temp_read]);
                  pingwriter.writerow([time.time(),ping_mesured])

                  puissancewriter.writerow([time.time(),puissance_read]);                    

                  ##########################################
              else:
                  print("\n###############################\n");
                  print("ON AIR");
                  print("\n###############################\n");
              temp_file.close();          
              puissance_file.close();
              ping_file.close();

              traficping_file.close();
              traficrssi_file.close();

              cpt_trames_temp = cpt_trames;

  ###############################################################################
  
  ###############################################################################
  #MAIN   
  ###############################################################################
  if __name__ == '__main__':   
      Recorder();     
  ###############################################################################