"""
  Created on Thu Jan 18 14:28:42 2018
  @author: Robin Cavalieri
  Réseau de neurones 
  P32 : Apprentissage DoS
  PFE 2018 - IMA5SC Polytech Lille
  """

  #Programme générique. N'oubliez pas de changer les PATHS

  ###############################################################################
  #LIBRAIRIES UTILES
  ###############################################################################
  import numpy as np
  import pandas as pd

  import csv

  # Modelisation
  from sklearn.model_selection import train_test_split
  from sklearn.preprocessing import StandardScaler
  from sklearn.metrics import confusion_matrix
  # Réseau de neurones 
  from keras.models import Sequential

  from keras.layers import Dense

  ###############################################################################
  
  ###############################################################################
  #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');
  
  #Concaténation des datasets de même classe 1-Normal 2- Attaque
  temp = dataset_rssi_norm.iloc[:,1].values;
  dataset_norm = np.c_[dataset_ping_norm, temp];
  temp = dataset_rssi_attack.iloc[:,1].values;
  dataset_attack = np.c_[dataset_ping_attack, temp];
  
  #Concaténation des datasets de même type
  dataset = np.concatenate((dataset_attack, dataset_norm), axis=0);
  
  #Récupération de la taille des matrices de données 
  [nSizeX, nSizeY] = np.shape(dataset);
  
  #On mélange les données pour éviter un apprentissage par fontière
  np.random.shuffle(dataset);
  
  #Sortie associée (correspond à la classe attaque ou non : colonne 1)
  target = dataset[:, 0];
  
  #Données d'entrée (ping : colonne 2 et rssi : colonne 3)
  #data = dataset[:,1];
  data = dataset[:,0:nSizeY-1];
  
  #80% des données utilisées à l'entrainement et 20% des données en test 
  data_train, data_test, target_train, target_test = train_test_split(data, target, test_size = 0.2, random_state = 0);
  
  #Normalisation des données 
  sc = StandardScaler();
  data_train = sc.fit_transform(data_train);
  data_test = sc.transform(data_test);
  ###############################################################################
  
  ###############################################################################
  #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(32, activation='relu', input_dim=2))
  #Couche de sortie
  classifier.add(Dense(1, activation='sigmoid'))

  ###############################################################################
  
  ###############################################################################
  #COMPILATION
  ###############################################################################
  # optimizer : algorithme choisi pour trouver le model (le plus puissant)
  # loss : Si deux valeurs en sortie (binairie outcome) : binary_crossentropy
  classifier.compile(optimizer = 'rmsprop', loss = 'binary_crossentropy', metrics = ['accuracy']);
  ###############################################################################
  
  ###############################################################################
  #TRAINING
  ###############################################################################

  classifier.fit(data_train, target_train, batch_size =1, epochs=10);

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

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

  #TAUX DE REUSSITE A PARTIR DES DONNEES DE TEST

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

  data_pred = classifier.predict(data_test);
  # Conversion en True ou False les predictions
  # Si y_pred > 0.5 : True 
  data_pred_binary = (data_pred > 0.5);
  # Matrice de cout
  cm = confusion_matrix(target_test, data_pred_binary);
  #dire qu'un trafic normal est une attaque
  good_prediction = cm[0, 0] + cm[1, 1];
  #dire qu'une attaque est un trafic normal 
  bad_prediction = cm[1, 0] + cm[0, 1];  
  taux_succes = good_prediction * 100 / (good_prediction + bad_prediction);

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

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

  #SAUVEGARDE DU TRAINING SET

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

  #Le modèle est mis au format JSON 
  classifier_json = classifier.to_json();
  with open('C:/Users/Utilisateur/PFE/python/Training/training.json',"w") as json_file : 
      json_file.write(classifier_json);
  #Les poids sont mis en HDF5

  classifier.save_weights("C:/Users/Utilisateur/PFE/python/Training/training.h5");
  ###############################################################################
  

  ##########################################################################################
  #REALISER DES PREDICTIONS
  ##########################################################################################
  dataset_to_pred = pd.read_csv('C:/Users/Utilisateur/PFE/python/datasets/data_to_pred.csv', quoting=csv.QUOTE_NONE);
  [xSizePred, ySizePred] = np.shape(dataset_to_pred);
  data_to_pred = dataset_to_pred.iloc[:, 0: ySizePred].values;
  predictions = classifier.predict(data_to_pred);
  
  predictions_named = [];
  
  for x in range(0, xSizePred-1):
      if predictions[x] > 0.5:
          predictions_named.append("Attaque")

      else:

          predictions_named.append("RAS")
  ##########################################################################################