"""
  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',
   #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;
  ##############################################################################
  
  ###############################################################################
  #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

      print(dataset_ping_temp);

      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 = 5;
      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;
      

      while(1):
          #RECUPERATION DES DONNEES
          x = ser.readline();
          
          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");
              elif(state_ping == 1):
                  print("PING ATTAQUE\n");
              if(state_rssi == 0):
                  print("RSSI NORMAL\n");
              elif(state_rssi == 1):
                  print("RSSI ATTAQUE\n");

              print("###############################\n");
      
          cpt_trames_temp = cpt_trames;
  ###############################################################################
  
  ###############################################################################
  #MAIN   
  ###############################################################################
  if __name__ == '__main__':   
      Recorder();     
  ###############################################################################