#include <iostream.h>
#include <stdlib.h>
#include <math.h>


/* les paramètres de la simulation */
const double probabilite =  0.05; /* prob. d'arrivee d'un client a chaque minute */
const long   minService  = 5;     /* temps minimum requis pour raser un client (en min.) */
const long   maxService  = 25;    /* temps maximum requis pour raser un client (en min.) */

/* ce qui est nécessaire pour représenter un client */
class tClient{
     private:
          long harrivee; /* Heure d'arrivée exprimée en minutes */
     public:
          tClient(void) {harrivee = 0;}
          tClient(long);
          long Harrivee(void)  { return harrivee;}
};

ostream & operator << (ostream & os, tClient & C){
    os << "\nclient arrivee a H" << C.Harrivee();
    return os;
}

ostream & afficherClient(ostream & os, tClient & C){
    os << "\nclient arrivee a H" << C.Harrivee();
    return os;
}

/* ce qui est nécessaire pour représenter LE BARBIER */
class Tfile{
	 private:
			tClient * tab;
			long taille;
			long longueurFile;
			long devant;
			long derriere;
			void enleveUnePlaceDevant(void);
			void faitUnePlaceDerriere(void);
	 public:
			Tfile(void);
			Tfile(long nbVoulu);
			~Tfile(void);

			int enfile(tClient valeur);
			tClient defile(void);
			int fileVide(void) const;
         void afficherTous(void) const;
};

const int LIBRE = 1;
const int OCCUPE = 0;

class tBarbier{
     private:
          int etat;           /* LIBRE OU OCCUPE */
          long tempsService;  /* temps nécessaire pour raser le client courant */
          long nbClients;     /* nb de clients servis au total */
          long tempsLibre;    /* nb de minutes où le barbier est libre */
          long tempsOccupe;   /* nb de minutes où le barvier est occupé */
          long tempsAttente;  /* grand total des temps d'attente de tous ses clients */
          tClient client;     /* le client qui se fait servir */
          Tfile  LAFILE;
     public:
          tBarbier(void);     /* constructeur */
          void travaille(long);
          void afficherStats(long) const;
          void gereTaFile(long);
        };



/* prototype pour la simulation du barbier */
long genererTempsService(void);
int ClientArrive(void);

double alea(void);
long aleaMinMax(long inf, long sup);


/* ------------------------------------------------------- MAIN */
int main(void){
  tBarbier Barbier;
  long Horloge;
  long Duree;
  
  cout << "Duree de la simulation : ";
  cin >> Duree;
  for (Horloge = 0; Horloge < Duree; Horloge++){
     Barbier.gereTaFile(Horloge);
     Barbier.travaille(Horloge);
  }
  
  Barbier.afficherStats(Duree);

  return EXIT_SUCCESS;
}

/* ----------------------------------------------------- BARBIER */
tBarbier::tBarbier() : client(), LAFILE(300) {
  etat = LIBRE;
  tempsService = 0;
  nbClients = 0;
  tempsLibre = 0;
  tempsOccupe = 0;
  tempsAttente = 0;
}

void tBarbier::gereTaFile(long Horloge){
     if (ClientArrive()){
        tClient C(Horloge);
        LAFILE.enfile(C);
        cout << "\nA H" << Horloge << " Arrivee d'un nouveau client.";
     }
}

void tBarbier::travaille(long Horloge){
     if (etat == OCCUPE){
       tempsOccupe++;
       if (tempsService == 0){
          etat = LIBRE;
          nbClients++;
          cout << "\nLe client arrive a H" << client.Harrivee() <<
                  " est satisfait a H" << Horloge;
       }
       else {
         tempsService--;
       }
     }
     else if (! LAFILE.fileVide()){
       client = LAFILE.defile();
       tempsService = genererTempsService();
       etat = OCCUPE;
       tempsOccupe++;
       tempsAttente += (Horloge - client.Harrivee());
       cout << "\nA H" << Horloge << " le client arrivee a H" <<
              client.Harrivee() << " se fait servir.\nIl a attendu " <<
              Horloge - client.Harrivee() << " minutes.";
     }
     else
       tempsLibre++;
}

void tBarbier::afficherStats(long Duree) const{
  cout << "\n\nTaux d'occupation du barbier : " << 1.0 * tempsOccupe / Duree;
  cout << "\nTaux de temps libre du barbier : " << 1.0 * tempsLibre / Duree;
  cout << "\nNombre de clients servis : " << nbClients;
  cout << "\nTemps moyen d'attente par client : " << 1.0 * tempsAttente / nbClients;
}



/* ---------------------------------------------------- CLIENT */
tClient::tClient(long Horloge){
  harrivee = Horloge;
}

/* ---------------------------------------------------- LA FILE DE CLIENT */
Tfile::Tfile(void){
	 taille = 0 ; tab = 0; longueurFile = 0;
   devant = -1; derriere = -1;
}

Tfile::Tfile(long nbVoulu){
	taille = 0; tab = 0; longueurFile = 0;
  devant = -1; derriere = -1;
	if (nbVoulu > 0) {
		 tab = new tClient[nbVoulu];
		 if (tab){ cout << "\nOK\n";
				taille = nbVoulu;}
	}
}

Tfile::~Tfile(void) {
	if (tab) delete[] tab;
}

int Tfile::fileVide(void) const{
   return longueurFile == 0;
}

void Tfile::enleveUnePlaceDevant(void){
   longueurFile--;
   if (longueurFile)
      devant = (devant + 1) % taille;
   else
      devant = derriere = -1;
}

void Tfile::faitUnePlaceDerriere(void){
   longueurFile++;
   derriere = (derriere + 1) % taille;
}

int Tfile::enfile(tClient valeur){
  faitUnePlaceDerriere();
	if (derriere ==  devant) {
		cout << "\nprobleme dans Enfile";
		return 0;
	}
	tab[derriere] = valeur;
	if (longueurFile == 1) devant = derriere;
	return 1;
}

tClient Tfile::defile(void) {
   if (! fileVide()) {
     tClient elem = tab[devant];
     enleveUnePlaceDevant();
	  return elem;
	}
  cout << "\nprobleme dans Defile";
  return 0;
}

void Tfile::afficherTous(void)const{
		 for (long i = 0; i < taille; i++)
				// cout << "\nFile[" << i << "] = " << afficherClient(cout,tab[i]);
				 cout << "\nFile[" << i << "] = " << tab[i];
}
/* ---------------------------------------------------- UTILITAIRES de simulation */
long genererTempsService(void){
  return aleaMinMax(minService, maxService);
}

int ClientArrive(void){
  return alea() < probabilite;
}
/* ---------------------------------------------------- UTILITAIRES random */
double alea(void){
   return (double) rand()/(RAND_MAX + 0.5);
}
long aleaMinMax(long inf, long sup){
   return (long) (inf + alea() * (sup - inf));
}