#include <iostream.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "Liste.h"




int NMax;
float lambda0;            //lambda0 on aura lambda (Paramètre de la loi exponentielle) = file*lambda0
float *dateLibre;         //Dates auxquelles les serveurs sont libres
int serveur;              //numéro du serveur dans lequel se trouve le processus
int serveurSuivant;       //numéro du prochain serveur sur la route
int compteur;             //nombre de processus générés
Liste* pile;              //Liste contenant tous les processus
int experience;           //Numéro de l'expérience
float *fin_on;            //date de fin de la prochaine période On
float *duree_off;         //Durée de la période Off
float *perteFile;         //Nombre de pertes sur une file
float *perteRoute;        //Nombre de pertes sur une route 
int topologie;            //Topologie du réseau



//Pour les statistiques
int *totalSorties;        //Nombre de sorties extérieures par routes
float *totalIntervalles;  //Somme des intervalles de sorties pour une route donnée
float *derniereSortie;    //date de dernière sortie d'un processus
int *totalEntrees;        //Nombre d'entrees extérieures par routes
float *totalIntervallesEntrees;//Somme des intervalles d'entree pour une route donnée
float *derniereEntree;    //date de dernière sortie d'un processus
float *totalTempsReponse; //Somme des temps de présence dans une file
int *totalEntreesReelles; //Nombre de toutes les entrées confondues
int *totalSortiesReelles; //Nombre de toutes les sorties confondues
float *totalTempsReponseRoute; //Somme des temps de réponse pour chaque route.
                               //En fonction de la TTL d'un processus, on peut déterminer sur quelle route il se trouve.
float ***nbClients;        //Variation du Nombre de clients (avec date) présents dans chaque file
int *indice;               //Conserve les indices de parcours de chaque tableau nbClients
int *calculClients;        //Nombre de clients dans la file à un instant donné
int *maxiClients;          //Nombre maxi de clients dans chaque file
int *repSup10;             //Nombre de temps de réponse supérieurs à 10ms
int *repSup20;             //...20ms
int *repSup50;             //...50ms
bool encours;        
float *dateEntree;         //Sauvegarde la dernière date d'entrée






//Fonction de sauvegarde d'un tableau dans fichier
void toFic(char* fichier,float** tab, int numFile){
  FILE* desc;
  desc=fopen(fichier,"w+");  
  for(int i=0; i<indice[numFile]; i++){
    fprintf(desc,"%.12f %.0f\n", tab[i][0], tab[i][1]);
  }
  fclose(desc);
}






//Fonction de création du fichier de commandes
void toCommandes(char* commandes){
  FILE* desc;
  desc=fopen("commandes","w+");  
  fprintf(desc,"%s\n", commandes);
  fclose(desc);
}






//Fonction pour tracer toutes les courbes statistiques
void tracerCourbes(){
  for(int i=0; i<6; i++){
    char temp[256];
    sprintf(temp, "Sommet %i",i+1);
    toFic(temp , nbClients[i], i);
  }
  toCommandes("plot \"Sommet 6\" with steps, \"Sommet 1\" with steps, \"Sommet 2\" with steps, \"Sommet 3\" with steps, \"Sommet 4\" with steps, \"Sommet 5\" with steps;");
  system("gnuplot -persist commandes");
}






//retourne le max de 2 entiers
float max(float i, float j){
  return((i>j)?i:j);
}





//Nettoyage des fichiers superflus
void nettoyage(){
  system("rm *.o");
  system("rm commandes");
  system("rm Sommet*");
}





//nb aleatoire entre 0 et 1
float uniforme() {
  return random()/(double)RAND_MAX;
}





//Distribution exponentielle
float exponentielle(float l){
  return(-log(random()/(double)RAND_MAX)/l);
}






//Génère le temps de service en fonction des expériences
float tempService(){
  switch(experience){
  case 1:
  case 2:{
    //Le paramètre de exponentielle est le débit. Pour un intervalle de temps moyen de 0.001s
    //le débit lambda0 est de 1000 s-1
    return (exponentielle(1000));
    break;
  }
  case 3:
  case 4:{
    return (0.001);
    break;
  }
  }
}







//Calcul des dates de fin de chaque période On et Off
//La première période commence à 0.
void onOff(int file){
  /*Date de fin de la période On en cours 
    = derniere date de fin 
    + durée de la période Off 
    + durée de la période On en cours)*/
  fin_on[file]+=duree_off[file]+0.02; 
  duree_off[file]=exponentielle((file*lambda0)/(20-lambda0*file*0.02));//Durée de la prochaine période Off
}






//Génère la prochaine arrivée en fonction de l'expérience
float genereSuivant(float date, int file){
  file++;  //La file i commence sur le somment i-1
  switch(experience){
  case 1:{
    //pour le débit de chaque file, on fixe le paramètre de exponentielle à lambda0*file
    return (date + exponentielle(lambda0*file));
    break;
  }
  case 2:
  case 3:
  case 4:{
    float tmp;
    tmp = date + 0.001;
    while(tmp>fin_on[file]) {
      tmp+=duree_off[file]; //Ajout de la durée de la période Off
      onOff(file);        //Nouvelle date On et Off
    }
    return (tmp);
    break;
  }
  }
}







//Fonction d'affichage
void afficherStatistiques(){
   float tpsService = 0.001;
  cout<<"Données"<<endl;
  cout<<"      nombre de paquets \t"<<NMax<<endl;
  cout<<"      temps de service \t"<<endl;
  cout<<"      arrivée des paquets \t"<<endl<<endl;
  
  for (int i=0; i<6; i++){
    float nbentrees = NMax*(i+1)/21;
    float entreePrecedent = ((i==0)?NMax*6/21:NMax*i/21);
    float entreePrecPrecedent = ((i<2)?NMax*(5+i)/21:NMax*(i-1)/21);
    float totalNombreEntrees = nbentrees + entreePrecedent + entreePrecPrecedent;
    float debitEntree = (i+1)*lambda0;
    float debitEntreeTotal = debitEntree + ((i<1)?6*lambda0:i*lambda0) + ((i<2)?(5+i)*lambda0:(i-1)*lambda0);

    float nbsorties = ((i<2)?NMax*(5+i)/21:NMax*(i-1)/21);
    float totalNombreSorties = nbsorties + entreePrecedent + entreePrecPrecedent;
    float debitSortie = ((i<2)?lambda0*(5+i):lambda0*(i-1));

    char tpsRep[256];
    sprintf(tpsRep, "%.4f",totalTempsReponse[i]/totalSortiesReelles[i]);

    float tempsRep;
    float interA = 1/debitEntreeTotal;
    if (tpsService<interA) tempsRep = tpsService;
    else tempsRep = ((2*tpsService+(tpsService-interA)*(totalNombreEntrees+1))/2);

    float nbMax;
    if (tpsService<interA) nbMax = 1;
    else nbMax = ((tpsService-interA)*totalNombreEntrees)/tpsService;
    
    

    cout<<"Sommet "<<i+1<<endl;
    cout<<"      nombre d'entrées ext \t"<<totalEntrees[i]<<"\t("<<nbentrees<<")"<<endl;
    cout<<"      entrées totales   \t"<<totalEntreesReelles[i]<<"\t("<<totalNombreEntrees<<")"<<endl;
    cout<<"      débit d'entrée ext \t"<<(totalEntrees[i]/totalIntervallesEntrees[i])<<"\t("<<(debitEntree)<<")"<<endl;
    cout<<"      débit d'entrée tot \t"<<totalEntreesReelles[i]/dateEntree[i]<<"\t("<<debitEntreeTotal<<")"<<endl<<endl;

    cout<<"      nombre de sorties ext\t"<<totalSorties[i]<<"\t("<<nbsorties<<")"<<endl;
    cout<<"      sorties totales   \t"<<totalSortiesReelles[i]<<"\t("<<totalNombreEntrees<<")"<<endl;
    cout<<"      débit de sortie ext \t"<<(totalSorties[i]/totalIntervalles[i])<<"\t("<<debitSortie<<")"<<endl;
    cout<<"      débit de sortie tot \t"<<(totalSortiesReelles[i]/dateLibre[i])<<"\t("<<debitEntreeTotal<<")"<<endl<<endl;

    cout<<"      temps de rép moy  \t"<<tpsRep<<"\t("<<tempsRep<<")"<<endl;
    cout<<"      nbre maxi clients \t"<<maxiClients[i]-1<<"\t("<<nbMax<<")"<<endl<<endl;

    cout<<"      proba tpsRep>50ms \t"<<100*repSup50[i]/totalSortiesReelles[i]<<" %"<<endl;
    cout<<"      proba tpsRep>20ms \t"<<100*repSup20[i]/totalSortiesReelles[i]<<" %"<<endl;
    cout<<"      proba tpsRep>10ms \t"<<100*repSup10[i]/totalSortiesReelles[i]<<" %"<<endl<<endl;
    if (experience==4){
      cout<<"      nbre de perte     \t"<<perteFile[i]<<endl;
      cout<<"      taux de perte     \t"<<100*perteFile[i]/totalEntreesReelles[i]<<" %"<<endl;
    }
  }
  cout<<endl;
  for (int i=0; i<6; i++){
    char tpsRepRoute[256];
    sprintf(tpsRepRoute, "%.4f",totalTempsReponseRoute[i]/totalEntrees[i]);

    cout<<"Route "<<(i+1)<<endl;
    cout<<"      temps de réponse  \t"<<tpsRepRoute<<"\t()"<<endl;
    if (experience==4){    
      cout<<"      nbre de perte     \t"<<perteRoute[i]<<"\t()"<<endl;
      cout<<"      taux de perte     \t"<<100*perteRoute[i]/totalEntrees[i]<<" %"<<"\t()"<<endl;
    }
  }
}






//Fonction d'initialisation des paramètres
void init(int argc, char** argv){
  encours = true;
  if (argc == 5){
    topologie = atoi(argv[1]);
    experience = atoi(argv[2]);
    lambda0 = atof(argv[3]);
    NMax = atoi(argv[4]);
  }
  else{
    topologie = 1;
    NMax=10000;
    experience = 1;
    lambda0 = 0.01;
  }


  //DatesLibres des Files
  dateLibre = new float[6];
  for (int i=0; i<6; i++){
    dateLibre[i] = 0;
  }

  //différents Tableaux
  indice = new int[6];
  nbClients = new float**[6];
  totalIntervalles = new float[6];
  totalIntervallesEntrees = new float[6];
  totalSorties = new int[6];
  totalEntrees = new int[6];
  derniereSortie = new float[6];
  derniereEntree = new float[6];
  totalTempsReponse = new float[6];
  totalEntreesReelles = new int[6];
  totalSortiesReelles = new int[6];
  totalTempsReponseRoute = new float[6];
  calculClients = new int[6];
  maxiClients = new int[6];
  repSup10 = new int[6];
  repSup20 = new int[6];
  repSup50 = new int[6];
  fin_on = new float[6];
  duree_off = new float[6];
  perteFile = new float[6];
  perteRoute = new float[6];
  dateEntree = new float[6];
  for(int i=0; i<6; i++){
    indice[i]=0;
    totalSorties[i]=0;       
    totalEntrees[i]=0;       
    totalIntervallesEntrees[i]=0;  
    totalIntervalles[i]=0;  
    derniereSortie[i]=0;  
    derniereEntree[i]=0;  
    totalTempsReponse[i]=0;
    totalEntreesReelles[i]=0;
    totalSortiesReelles[i]=0;
    totalTempsReponseRoute[i]=0;
    calculClients[i]=0;
    maxiClients[i]=0;
    repSup10[i]=0;
    repSup20[i]=0;
    repSup50[i]=0;
    fin_on[i]=0;
    duree_off[i]=0;
    perteFile[i]=0;
    perteRoute[i]=0;
    dateEntree[i]=0;
  } 
  for(int i=0; i<6; i++){
    nbClients[i] = new float*[2*NMax];
    for(int j=0; j<(2*NMax); j++){
      nbClients[i][j] = new float[2];
    }
  }
}






//Fonction retournant à quelle route le paquet appartient en fonction de sa TTL et du serveur
int quelleRoute(int serv, int ttl){
  int tmp = serv-3+ttl;
  return ((tmp>=0)?tmp:6+tmp);
}






//Renvoie le serveur suivant de manière aléatoire
int nextServeur(int s){
  if(topologie==1) return((s==5)?0:s+1);
  else{
    int temp=s;
    while((s==temp)||(temp==6)){
      temp = (int)(6*(random()/(double)RAND_MAX));
    }
    return(temp);
  }
}






//Fonction principale
int main(int argc, char** argv){
  init(argc, argv);


  //Création de l'arrivee des premiers processus pour chaque file
  pile = new Liste();
  Cell* tempo=new Cell(-1, 'A', 0.001, 3, -1);
  pile->insere(tempo);
  compteur = 6;
  for(int i=0; i<6; i++) {
    totalEntrees[i]=1;
    derniereEntree[i] = 0.001;
    tempo=new Cell(i, 'A', 0.001, -1, i);
    pile->insere(tempo);
    onOff(i);
  }
  
  



  Cell* test=pile->premier();
  //Parcours de la liste jusqu'à peut plus
  while(test!=pile->dernier()) {
    pile->enleve(test);
    serveur = test->getNumFile();
    serveurSuivant = nextServeur(serveur); 
    switch(test->getType()){
    case 'A':{
 

     //Statistique (Nombre total de toutes les entrées)
      totalEntreesReelles[serveur]++;



      //*** Prochaine arrivée sur ce serveur ***
      float suivant;
      if ((test->getTTL()==-1)&&(compteur<NMax)){  //si arrivée extérieure
	suivant = genereSuivant(test->getDate(), serveur);
	dateEntree[serveur] = suivant;
	int ttl = ((topologie==1)?3:-1);
	Cell* prochain = new Cell(compteur, 'A', suivant, ttl, serveur);
	pile->insere(prochain);
	compteur ++;
	
	//Statistiques
	totalEntrees[serveur]++;
	totalIntervallesEntrees[serveur] += (suivant - derniereEntree[serveur]);
	derniereEntree[serveur] = suivant;
      }
      //*** Fin Prochaine arrivée sur ce serveur ***




      //On limite la capacité de la file à 100
      if ((experience==4)&&(calculClients[serveur]>100)){
	perteFile[serveur]++;
	perteRoute[quelleRoute(serveur, test->getTTL())]++;
      }



      else{

	//*** Calcul Fin du traitement de ce processus ***
	dateLibre[serveur]=max(dateLibre[serveur], test->getDate())+tempService();//Calcul de la date libre apres le traitement du processus
	Cell* fin=new Cell(test->getNumProc(), 'F', dateLibre[serveur], test->getTTL(), serveur);
	pile->insere(fin);
	//*** Fin Calcul Fin du traitement de ce processus ***






	//Statistique (temps de réponse)
	totalTempsReponse[serveur]+=(dateLibre[serveur]-test->getDate()); 
	totalTempsReponseRoute[quelleRoute(serveur,test->getTTL())]+=(dateLibre[serveur]-test->getDate());
	//*** Fin Calcul Fin du traitement de ce processus ***




	//Statistique (probabilité du temps de réponse)
	if(dateLibre[serveur]-test->getDate()>0.05) repSup50[serveur]++;
	if(dateLibre[serveur]-test->getDate()>0.02) repSup20[serveur]++;
	if(dateLibre[serveur]-test->getDate()>0.01) repSup10[serveur]++;




	//Statistique (nombre de clients dans la file)
	calculClients[serveur]++;
	nbClients[serveur][indice[serveur]][0]=test->getDate();
	nbClients[serveur][indice[serveur]][1]=calculClients[serveur];  
	if(calculClients[serveur]>maxiClients[serveur]) maxiClients[serveur]=calculClients[serveur]; //Sauvegarde du maxi de clients simultanés dans la file
	indice[serveur]++;
      }
      break;
    }



    case 'F':{
      //Nombre total de toutes les sorties
      totalSortiesReelles[serveur]++; 



      //Statistiques
      calculClients[serveur]--;
      nbClients[serveur][indice[serveur]][0]=test->getDate();
      nbClients[serveur][indice[serveur]][1]=calculClients[serveur];      
      indice[serveur]++;



      //*** Transfert du processus sur serveur suivant ***
      if ((topologie==1)&&(test->getTTL()>1)){
	Cell* prochain = new Cell(test->getNumProc(), 'A', test->getDate(), test->getTTL()-1, serveurSuivant);
	pile->insere(prochain);
      }
      if (topologie==2){
	if (test->getTTL()==-1){
	  Cell* prochain = new Cell(test->getNumProc(), 'A', test->getDate(), serveur, serveurSuivant);
	  pile->insere(prochain);
	}
	else if(test->getTTL()>-1){
	  Cell* prochain = new Cell(test->getNumProc(), 'A', test->getDate(), -2, test->getTTL());
	  pile->insere(prochain);	
	}
      }
      //*** Fin Transfert du processus sur serveur suivant ***
      


      //Gestion des statistiques
      if (test->getTTL()==-2){
	totalSorties[serveur]++;
	totalIntervalles[serveur] += test->getDate() - derniereSortie[serveur];
	derniereSortie[serveur] = test->getDate();
      }
      break;
    }
    }
    test=pile->premier();
  }

  //tracerCourbes();
  afficherStatistiques();
  //nettoyage();
}