#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <conio.h>
#include <dos.h>
#include <iostream.h>
#include <iomanip.h>

template <class tavenir>
class Tfile{
	 private:
			tavenir* tab;//tableau contenant les elements de la file
			tavenir poubelle;
			int	 	taille;//nb rangee dans la file
			int	 	devant;
			int	 	derriere;
			int  	enleveuneplacedevant(void);
			void 	faitUnePlaceDerriere(int &);
			tavenir rempliladerniercase(tavenir valeur,int& nbrangeevide,int nb);
			int  	initialisation (int);
			int		initialise(int,int);
			int 	fileVide(void);
	 public:
			Tfile(int anode);
			Tfile();
			Tfile(int,long);
			~Tfile(void);
			int 	refroidis(int nbminute,int,int);//Quand une rangee est pleine, la 
fait refroidir et quand elle est froide, l'enleve
			int 	enfile(tavenir valeur,int&,int);
			tavenir defile(tavenir,int&);
			void 	afficherTous();
			void 	coulecreset(int pas,int& longeurfile,int);//Coule l'aluminium dans 
le creset
			void 	enlevecreset(int pas,int& longeurfile,int nb);//Quand le creset est 
plein, on l'enleve
			tavenir& operator[](int i);
			void	afficher();
};

class fonderie{
	private:
		Tfile<int>	filecreset;
		int 	taille;
		int 	longeurfile;
	public:
		fonderie(int);
		void	travaille(int);//Coule creset et enleve creset
		void	afficher();
};

class entrepot{
	private:
		Tfile<int>	filecabanode;//L'entrepot contient differente file
		Tfile<int>	filecabmegot;
		Tfile<int>	filebennevide;
		Tfile<int>	filebennepleine;
		int 		nbrangeevide;//Nombre de rangee vide dans l'espace reserve aux 
cabarets
		int			rangeebennevide;//Nombre de rangee vide dans l'espace reserve aux 
bennes
		double	megot;
		double	anode;
		double	bennesvides;
		double	bennespleines;
		void		bennerefroidi(int);//Refroidis les bennes pleines pendant 15 heures
	public:
		entrepot(int nbrangee,long anode,long benne,long,int,int);
		void		afficher() const;
		int 		recoitanode(int cab);//Recoit les anode reparees provenant de la 
salle de scellement
		int 		recoitbenne(int,int);//Recoit les bennes pleines de la salle 
d'electrolyse
		void		travailler(int nbminute);
		int			recoitcab(int nbcab);//Recoit les cabarets de megot de la salle 
d'electrolyse et les enfile
		void		setanode(double);
		double 	getanode(void) const;
		void		setmegot(double);
		double 	getmegot(void) const;
		int 		envoitcab(int);//Envoit des cabarets d'anodes a la salle 
d'electrolyse
		int			megotrefroidis(int nbminute);//Refroidis les megots pendant 4 heures
};

class scellement{
	private:
		double 	anode;
		int			minutesnontravaille;
		const	int	tauxreparation;//defini par l'usager
		double	megot;
		int 		travaillestu;
		void		retourneanode(entrepot& x);//Retourne les anodes reparees en 
entrepot
		int			horaire(int);//Sommes nous dans des heures de travail ou de repos
	public:
		scellement(double);
		void  	travailler(int,entrepot&);
		void		afficher(void) const;
		void		setanode(double);
		double 	getanode(void) const;
		void		setmegot(double);
		double 	getmegot(void) const;
};

class electrolyse{
	private:
		int			cab;
		double	megot;
		double	anode;
		double	bennespleines;
		const double	prodanode;//defini par l'usager
		int			envoitbenne(entrepot&,int);//envoit les bennes pleines a l'entrepot
		int 		recoitcab(int nbcab,entrepot& x);//Recoit les cabarets d'anode de 
l'entrepot
	public:
		electrolyse(double);
		int			travaille(int nbminute,entrepot& x);//temps qui s'ecoule entre 
chaque coup d'horloge
		void 		envoitcab(int nbcab,entrepot& x);//Envoie les cabarets de megot en 
entrepot
		void		recoitanode(entrepot&);//Recoit des anodes s'il y a eu un manque en 
entrepot plus tot
		void 		afficher (void) const;
		void		setanode(double);
		double 	getanode(void) const;
};


int main(void){
	int 
arret,pas,nbrangee,anode,nbbennes,creset,nbrangeereste,nbrangeebennevide;
	char	tonnes,jump;
	double	prodanodes,tauxreparation,heure;
	long meg,i;
	do{
		 clrscr();
		 cout<<"Quel est le nombre de tonnes/heure?\n";
		 cout<<"A: 40  tonnes/heure ?\n";
		 cout<<"B: 60  tonnes/heure ?\n";
		 cout<<"C: 120 tonnes/heure ?\n";
		 cin>>tonnes;
	} while((tonnes!='a')&&(tonnes!='A')&&(tonnes!='b')&&(tonnes!='B')
						&&(tonnes!='c')&&(tonnes!='C'));
	if((tonnes == 'a')||(tonnes=='A')){
		pas = 15;
		prodanodes = 19.9;
		creset = 6;
	}
	if((tonnes == 'b')||(tonnes=='B')){
		pas = 10;
		prodanodes = 60*(19.9/40);
		creset = 9;
	}
	if((tonnes == 'c')||(tonnes=='C')){
		pas = 5;
		prodanodes = 120*(19.9/40);
		creset = 18;
	}
	fonderie	f(creset);
	electrolyse alu(prodanodes);
	do{
		cout<<"Taux de reparation des anodes en salle de scellement"<<endl;
		cin>>tauxreparation;
		if(tauxreparation<=0)
			cerr<<"Ce taux doit etre superieur a zero"<<endl;
	}while(tauxreparation<=0);
	scellement nettoyage(tauxreparation);
	do{
		do{
			cout<<"Entrer le nombre de rangee disponible pour stocker les cabarets: 
\n";
			cin>>nbrangee;
		}while(nbrangee>36 || nbrangee<0);
			do{
				cout<<"Combien d'anode voulez-vous mettre au depard dans l'entrepot 
(multiple de 6): \n";
				cin>>anode;
			}while(anode%6 || anode<=0);
			do{
				cout<<"Nombre de megots dans l'entrepot au depart (multiple de 
6)"<<endl;
				cin>>meg;
			}while(meg%6 || meg<0);
			if(anode%36)
				nbrangeereste=nbrangee-((anode/36)+1);
			else
				nbrangeereste=nbrangee-(anode/36);
			if(meg==0)
				nbrangeereste-=1;
			else{
				if(meg%36)
					nbrangeereste-=((meg/36)+1);
				else
					nbrangeereste-=(meg/36);
			}
			if(nbrangeereste<0)
				cout<<"Il n'y a pas assez de rangees pour le nombre de 
cabaret!!!"<<endl;
	}while(nbrangeereste<0);
	do{
		cout<<"Entrer le nombre de benne vide  au depart"<<endl;
		cin>>nbbennes;
		if(nbbennes%14)
			nbrangeebennevide=36-nbrangee-((nbbennes/14)+1);
		else
			nbrangeebennevide=36-nbrangee-(nbbennes/14);
		if(nbrangeebennevide<0)
			cout<<"Il y atrop de bennes vides pour le nombre de rangees 
restantes"<<endl;
	}while(nbrangeebennevide<0 || nbrangeebennevide<0);
	entrepot	stock(nbrangee,anode,nbbennes,meg,nbrangeereste,nbrangeebennevide);
	clrscr();

		cout<<"Pendant combien d'heures voulez-vous faire la simulation"<<endl;
		cin>>heure;
		for(i=0;i<heure*60;i+=pas){
			arret=alu.travaille(pas,stock);
			f.travaille(pas);
			if(!arret){
				alu.afficher();
				stock.afficher();
				nettoyage.afficher();
				f.afficher();
				cout<<"\n La simulation s'est arreter apres "<<((i-1))/60<<" 
heures"<<endl;
				getch();
				return 0;
			}
			nettoyage.travailler(pas,stock);
		}
		alu.afficher();
		stock.afficher();
		nettoyage.afficher();
		f.afficher();
		getch();

	return EXIT_SUCCESS;
}

/***************************** CONSNTRUCTEUR TFILE 
****************************

Constructeur pour la file de cabaret d'anode et pour la file de cabaret de
megot																																				*/
template <class tavenir>
Tfile<tavenir>::Tfile(int nbelement){
	tab = 0;
	devant = 0;
	int rangee;
	if(nbelement%36)//calcule le nombre de rangees necessaire pour le nb 
d'element
		rangee=(nbelement/36)+1;
	else
		rangee=(nbelement/36);
	if(rangee==0)
		rangee=1;
	tab = (tavenir*)malloc(rangee*sizeof(tavenir));
	if (tab){
		taille = rangee;
		derriere=initialisation(nbelement);
	}
	else{
		cout<<"Probleme dans le constructeur de filecab\n";
		getch();
	}
}

/*------------------------ TFILE::INITIALISATION---------------------------

Rempli la file suivant le nombre d'element qu'on veut y entrer. Ne 
s'applique
que pour les files de cabarets.
anode=nombre d'element a entrer dans la file*/
template <class tavenir>
int Tfile<tavenir>::initialisation(int anode){
	for(int i=0;i<taille;i++)
		tab[i]=0;
	int derriere=0;
	i=0;
	do{
		if(anode>0){
			anode-=6;
			tab[i]=tab[i]+1;
			if(tab[i]==6){
				derriere++;
				i++;
			}
		}
	}while(anode);
	return derriere;
}

/***************************** CONSTRUCTEUR TFILE 
***************************

Initialise la file de benne pleine et la file de creset*/
template <class tavenir>
Tfile<tavenir>::Tfile(){
	tab = 0;
	devant = 0; derriere = 0;
	tab =(tavenir*)malloc(1*sizeof(tavenir));
	if (tab){
		taille = 1;
		tab[0]=0;
	}
	else{
		cout<<"Probleme dans le constructeur de file vide\n";
		getch();
	}
}

/*---------------------------- CONSTRUCTEUR TFILE 
---------------------------

C'est le constructeur pour la file de benne vide	*/
template <class tavenir>
Tfile<tavenir>::Tfile(int nbvoulu,long benne){
	tab = 0;
	devant = 0;
	int rangee;
	if(benne%14)
		rangee=(benne/14)+1;
	else
		rangee=(benne/14);
	if(rangee==0)
		rangee=1;
	tab = (tavenir*)malloc(rangee*sizeof(tavenir));
	if (tab){
		taille = rangee;
		derriere=initialise(benne,14);
	}
	else{
		cout<<"Probleme dans le constructeur de filebennevide\n";
		getch();
	}
}

/************************** TFILE::INITIALISE 
********************************

Initialise la file de benne vide suivant le nombre desire de bennes vides*/
template <class tavenir>
int Tfile<tavenir>::initialise(int benne,int nb){
	for(int i=0;i<taille;i++)
		tab[i]=0;
	int derriere=0;
	i=0;
	do{
		if(benne>nb){
			benne-=nb;
			tab[i]=tab[i]+nb;
			if(tab[i]==nb){
				derriere++;
				i++;
			}
		}
		else{
			tab[i]=benne;
			benne=0;
		}
	}while(benne);
	return derriere;
}



template <class tavenir>
tavenir& Tfile<tavenir>:: operator[](int i){
	if (i>=taille){
		cout<<"Vous etes a l'exterieur du tableau \n";
		getch();
		return poubelle;
	}
	return tab[i];
}

template <class tavenir>
Tfile<tavenir>::~Tfile(void) {
	if (tab)
	free(tab);
}

/***************************** TFILE::FILEVIDE ****************************

Retourne 0 s'il ne reste plus rien sinon retourne un autre chiffre	*/
template <class tavenir>
int Tfile<tavenir>::fileVide(void){
	if(taille<=1)
		return tab[0];
	return 1;
}

/*********************** TFILE::FAITUNEPLACEDERRIERE ******************

Rallonge la file et initialise la dernier case a 0.
nbrangeevide est le nombre de rangees vides en entrepot*/
template <class tavenir>
void Tfile<tavenir>::faitUnePlaceDerriere(int& nbrangeevide){
	taille++;
	nbrangeevide--;
	tab=(tavenir*)realloc(tab,taille*sizeof(tavenir));
	derriere++;
	tab[derriere]=0;
}

/********************** TFILE::REMPLILADERNIERECASE 
*************************

Remplis la derniere case suivant le nombre d'element que l'on veut mettre et
retourne le nombre d'element non enfile
valeur correspond au nombre de bennes ou de cabaret a enfiler
nbrangeevide est le nombre de rangees vides en entrepot
nb correspond au nombre d'element que l'on peut mettre dans une rangee */
template <class tavenir>
tavenir Tfile<tavenir>::rempliladerniercase(tavenir valeur,int& 
nbrangeevide,int nb){
	tavenir temp=tab[derriere];
	if ((tab[derriere]+valeur)>=nb){//Si tout ne rentre pas dans la derniere 
rangee
		valeur-=(nb-tab[derriere]);//met ce que tu peut
		tab[derriere]=nb;
		if(nbrangeevide)
			faitUnePlaceDerriere(nbrangeevide);
		else{//Si on ne peut pas agrandir le tableau : PROBLEME !!!
			cout<<"Il n'y a plus de place dans la file !!\n";
			tab[derriere]=temp;
			return -1;
		}
	}
	return valeur;
}

/******************************* Tfile:: enfile *************************

Met des elements dans la file. Retourne -1 si la file est pleine sinon 
retourne
le nombre d'element enfile
valeur correspond au nombre de bennes ou de cabaret a enfiler
nbrangeevide est le nombre de rangees vides en entrepot
nb correspond au nombre d'element que l'on peut mettre dans une rangee */
template <class tavenir>
int Tfile<tavenir>::enfile(tavenir valeur,int& nbrangeevide,int nb){
	tavenir	cab=valeur;
	valeur=rempliladerniercase(valeur,nbrangeevide,nb);
	if(valeur==-1)//C'est qu'il n'y a plus de place dans la file PROBLEME !!!
		return -1;
	tab[derriere] += valeur;
	return (cab);
}

/************************** TFILE::DEFILE 
***********************************

Enleve valeur elements de la file.
valeur=nombre de cabaret ou de bennes a defiler
nbrangeevide=nombre de rangeevide en entrepot*/
template <class tavenir>
tavenir Tfile<tavenir>::defile(tavenir valeur,int& nbrangeevide) {
	 tavenir cab=valeur;
	while(fileVide() && valeur!=0){//Si la file n'est pas vide
		if(tab[devant]>valeur){      //defile
			tab[devant]-=valeur;
			valeur=0;
		}
		else{
			valeur-=tab[devant];
			//if(taille>1){
				enleveuneplacedevant();
				nbrangeevide++;
				tab[devant]-=valeur;
				valeur=0;
			//}
/*			else{
				valeur+=tab[devant];
				return -1;
			}*/
		}
	}
	if(valeur){
		if (!fileVide()) {//Si la file est vide retourne -1
			cout<<"la file est vide\n";
			return -1;
		}
	}
	return (cab-valeur);
}

/***************************** 
TFILE::AFFICHERTOUS**************************/
template <class tavenir>
void Tfile<tavenir>::afficherTous(){
	for (long i = 0; i < taille; i++)
		cout << "\ntab[" << i << "] = " << tab[i];
	cout<<"\n";
	getch();
}

/***************************** TFILE::REFROIDIS***************************

Refroidis ce qu'il y a dans la file et retourne le nombre de rangee 
refroidies
nbminute est le pas de simulation,
largeur la quantite de cabarets ou de bennes que l'on peut mettre dans une 
rangee,
temps le temps d'attente plus taille de la file pleine a attendre avant que 
la rangee soit refroidie*/
template <class tavenir>
int Tfile<tavenir>::refroidis(int nbminute,int largeur,int temps){
	int nb=0;
	for(int i=0;i<taille;i++){//Refroidis ce qu'il y a dans la file
		if(tab[i]>=largeur){
			tab[i]+=nbminute;
		}
	}
	i=0;
	for(;i<taille;i++){//Est-ce qu'une rangee est froide
		if(tab[i]>=temps)
				nb++;
	}
	int temp=nb;
	if(temp){//S'il y a une rangee froide
		do{
			if(enleveuneplacedevant());//alors enleve la rangee de la file
			temp--;
		}while(temp);
	}
	if(!temp)
		return nb;
	return (nb-temp);
}

/********************* TFILE::ENLEVEUNEPLACEDEVANT *************************

Enleve le premier element de la file et racourci le file*/
template <class tavenir>
int Tfile<tavenir>::enleveuneplacedevant(){
	for(int i=devant;i<taille;i++)//enleve le premier element et recule tous 
les elements d'une place
		tab[i]=tab[i+1];
	taille--;
	if(taille>=1){
		tab=(tavenir*)realloc(tab,taille*sizeof(tavenir));
		derriere--;
		return 1;
	}
	cout<<"La file est totalement libre";
	getch();
	return 0;

}

/************************** TFILE::COULECRESET *****************************

Coule l'aluminium dans les cresets.
pas= pas de simulation
longeurfile= nb d'element present sur la file
nb= nombre d'element que peut au maximum avoir la file*/
template <class tavenir>
void Tfile<tavenir>::coulecreset(int pas,int& longeurfile,int nb){
	for(int i=0;i<longeurfile;i++)
		tab[i]+=pas;
	if(taille<nb){
		longeurfile++;
		tab=(tavenir*)realloc(tab,longeurfile*sizeof(int));
		derriere++;
		taille++;
		tab[derriere]=0;
	}
}

/************************* TFILE::ENLEVECRESET *****************************

Quand le creset est plein, on l'enleve de la file. La file de creset peut
donc recevoir un nouveau creset vide.
pas= pas de simulation
longeurfile= nb d'element present sur la file
nb= nombre d'element que peut au maximum avoir la file */
template <class tavenir>
void Tfile<tavenir>::enlevecreset(int pas,int& longeurfile,int nb){
	for(int i=0;i<longeurfile;i++){
		if(tab[i]>=nb*pas){
			enleveuneplacedevant();
			taille++;
			derriere++;
			tab=(tavenir*)realloc(tab,longeurfile*sizeof(int));
			tab[derriere]=0;
		}
	}
}

/**************************** TFILE::AFFICHER 
*******************************/
template <class tavenir>
void Tfile<tavenir>::afficher(){
	cout<<"Temps de remplissage des cresets: [";
	for(int i=0;i<taille-1;i++)
		cout<<tab[i]<<" ";
	cout<<tab[i];
	cout<<"]"<<endl;
}


/************************ CONSTRUCTEUR FONDERIE *************************/
fonderie::fonderie(int nbvoulu):
	filecreset()//Creation de la file de creset
	{
	taille=nbvoulu;
	longeurfile=1;
}

/************************* FONDERIE::TRAVAILLE 
******************************

Cette fonction remplie les creset et les enleve quand ils sont pleins.
pas= pas de simulation*/
void fonderie::travaille(int pas){
	filecreset.enlevecreset(pas,longeurfile,taille);//enleve les cresets pleins
	filecreset.coulecreset(pas,longeurfile,taille);//met l'aluminum dans les 
cresets
}

/************************** FONDERIE::AFFICHER 
*****************************/
void fonderie::afficher(){
	filecreset.afficher();
}

/************* CONSTRUCTEUR DE LA SALLE DE SCELLEMENT *********************

Toutes la variables sont initialisees a zero sauf le taux de reparation des
megots qui est determine par l'usager																			*/
scellement::scellement(double reparation):	megot(0.0),anode(0.0),
	tauxreparation(reparation),minutesnontravaille(0),travaillestu(0){}

//*********************** Salle de scellement:Set anode
void scellement::setanode(double n){
	if(n>=0)
		anode=n;
	else
		cout<<"Le nombre d'anode ne peut pas etre negatif \n";
}

//*********************** Salle de scellement:Get anode
double scellement::getanode() const{
	return anode;
}

//*********************** Salle de scellement:Set megot
void scellement::setmegot(double n){
	if(n>=0)
		megot=n;
	else
		cout<<"Le nombre de megot ne peut pas etre negatif \n";
}

//*********************** Salle de scellement:Get megot
double scellement::getmegot() const{
	return megot;
}


/********************** SCELLEMENT::HORAIRE ********************************

Retourne 1 si on est en heure de travaille 0 sinon												*/
int scellement::horaire(int pas){
	if(travaillestu<0){
		travaillestu+=pas;
		return 0;
	}
	if(travaillestu==420){//420 = 7*60 Apres 7 heures, une heure de repos
		travaillestu = (pas-60);
		return 0;
	}
	travaillestu += pas;
	return 1;
}


//*************************fonction 
afficher***********************************
void scellement::afficher(void) const{
	cout<<"Nombre de megots restants en salle de scellement :  "<<megot<<"\n";
	cout<<"Nombre d'anodes restants en salle de scellement  :  "<<anode<<"\n";
}

/**************** SCELLEMENT::TRAVAILLER 	*****************************

Va chercher les megots refroidis en entrepot, les repare et les ramene dans
l'entrepot*/
void	scellement::travailler(int nbminute,entrepot& x){
	double repare=(double)(tauxreparation*nbminute)/60;
	if(horaire(nbminute)){
		if(megot>=repare){
				megot=megot-(repare);
				anode=anode+(repare);
				retourneanode(x);
		}
		else{
			//cout<<"C'est plutot tranquille en salle de scellement\n";
			//getch();
			minutesnontravaille=minutesnontravaille+nbminute;
		}
		int nombre=x.megotrefroidis(nbminute);//retourne la quantite de rangee 
refroidites
		if (nombre)
			megot+=nombre*36;
	}                      //attention anode scellement et entrepot
}

/******************* SCELLEMENT::RETOURNEANODE *********************

Retourne les anodes reparees en entrepot*/
void	scellement::retourneanode(entrepot& x){
	int cab;
	cab=(int)anode/6;
	x.recoitanode(cab);//envoit les cabarets en entrepot
	anode=anode-6*cab;//Les anodes quittent la salle de scellement
}


/************************* CONSTRUCTEUR DE L'ENTREPOT 
************************

Initialise l'entrepot suivant :
	-le nombre de rangee desire pour stocker les
cabarets. Le nombre de rangee disponible pour stocker les bennes se trouve
a correspondre au nombre de rangees restantes.
	-le nombre d'anode desirees
	-le nombre de megots desires
	-et le nombre de bennes desirees */
entrepot::entrepot(int nbrangee,long anod,long benne,long meg,int 
nbrangeereste,int nbrangeebenne):
	filecabanode(anod),//Appelle un constructeur Tfile
	filecabmegot(meg),
	filebennevide(36-nbrangee,benne),
	filebennepleine()
	{
	megot=meg;anode=anod;bennesvides=benne;bennespleines=0.0;
	nbrangeevide=nbrangeereste;
	rangeebennevide=nbrangeebenne;
}


//*************************fonction 
getmegot***********************************
double	entrepot::getmegot() const{
	return megot;
}

//*************************fonction 
getanode***********************************
double	entrepot::getanode() const{
	return anode;
}

//*********************** Entrepot:Set megot
void entrepot::setmegot(double n){
	if(n>=0)
		megot=n;
	else
		cout<<"Le nombre de megot ne peut pas etre negatif \n";
}

//*********************** Entrepot:Set anode
void entrepot::setanode(double n){
	if(n>=0)
		anode=n;
	else
		cout<<"Le nombre d'anode ne peut pas etre negatif \n";
}

//************************* ENTREPOT::AFFICHER 
******************************
void entrepot::afficher(void) const{
	cout<<"Nombre de megots restants en entrepot :  "<<megot<<"\n";
	cout<<"Nombre d'anodes restants en entrepot  :  "<<anode<<"\n";
	cout<<"Nombre de bennes pleines en entrepot :  "<<bennespleines<<"\n";
	cout<<"Nombre de bennes vides en entrepot  :  "<<bennesvides<<"\n";
}

/***************************** ENTREPOT::RECOITCAB 
***************************

Recoit les cabarets de megot de la salle d'electrolyse et les enfile.
S'il n'y a pas assez de place, il averti et retourne -1 sinon il retourne le
nombre de cabaret enfiles																									*/
int	entrepot::recoitcab(int cab){
	int erreur;
	erreur=filecabmegot.enfile(cab,nbrangeevide,6);
	if(erreur==-1){
		cerr<<"Il n'y a pas assez de place dans la file pour recevoir tous ces 
cabarets";
		getch();
		return -1;
	}
	megot+=6*erreur;
	return cab;
}

/************************ ENTREPOT::RECOITANODE *************************

Recoit les anode reparees provenant de la salle de scellement,
les mets dans la file et retourne le nombre de cabaret enfilees
cab : nombre de cabaret a enfiler*/
int entrepot::recoitanode(int cab){
	cab=filecabanode.enfile(cab,nbrangeevide,6);//enfile les cabarets
	if (cab==-1){
		cerr<<"Il n'y a plus assez de place pour enfiler toutes ces anodes"<<endl;
		getch();
		return 0;
	}
	anode+=6*cab;//augmente le nombre d'anodes
	return cab;
}

/*********************** ENTREPOT::RECOITBENNE *****************************

Recoit les bennes pleines de la salle d'electrolyse, verifie si des bennes
pleines ont eu le temps de refoirdir et retourne le nombre de bennes pleines
enfilees
paquet=bennes/2 a envoyer a l'entrepot
nbminute=pas de simulation	*/
int	entrepot::recoitbenne(int paquet,int nbminute){
	int erreur,pb;
	pb=filebennepleine.enfile(2*paquet,rangeebennevide,14);//retourne le nombre 
correctement enfile ou -1 si probleme
	erreur=filebennevide.defile(paquet*2,rangeebennevide);//retrourne le nombre 
de benne correctement defile
	if(erreur==-1){
		cerr<<"Il n'ya plus de bennes vides en entrepot"<<endl;
		getch();
		erreur=0;
	}
	bennesvides-=erreur;
	if(pb==-1){
		cerr<<"Il n'ya plus de place pour enfiler les bennes pleines"<<endl;
		getch();
		pb=0;
	}
	bennespleines+=pb;
	bennerefroidi(nbminute);
	return pb;
}

/******************** ENTREPOT::BENNEREFROIDI 
*******************************

Fait refroidir les bennes. Si des bennes sont froides, on les vides. Cela
diminuedonc le nombre de bennes pleines et augmente le nombre de bennes
pleines
nbminute=pas de simulation	*/
void entrepot::bennerefroidi(int nbminute){
	int nb,pb;
	nb= filebennepleine.refroidis(nbminute,14,(15*61));
	rangeebennevide+=nb;
	bennespleines-=14*nb;
//	filebennepleine.afficherTous();
	if(nb){
		pb=filebennepleine.defile(14*nb,rangeebennevide);
		pb=filebennevide.enfile(14*nb,rangeebennevide,14);
	}
	if(pb==-1){
		cout<<"Il n'y a plus de place pour enfiler une rangee de benne 
refroidi\n";
		getch();
	}
	bennesvides+=14*nb;
}

/************************ ENTREPOT::ENVOITCAB *****************************

Envoit des cabarets d'anodes a la salle d'electrolyse. S'il n'y a plus
d'anodes retourne -1
nbcab=nombre de cabaret d'anodes a retirer de l'entrepot	*/
int entrepot::envoitcab(int nbcab){
	int cab=nbcab;
	if(anode<6*cab){//S'il n'y a pas autant d'anode que demande
		cab=(int)anode/6;//envoit ce que tu peut
		anode=anode-6*cab;
		cout<<"Il manque d'anode en entrepot \n";
		getch();
		if(cab==0)
			return -1;
	}
	else
		anode=anode-cab*6;
	cab=filecabanode.defile(cab,nbrangeevide);//defile les cabaret d'anode
	return	cab;//retourne le nombre de cabaret defile
}

/********************** ENTREPOT::MEGOTREFROIDIS **************************

Retourne la quantite de rangees de megot refroidis pour pouvoir aller en
scellement*/
int entrepot::megotrefroidis(int nbminute){
	int nb=0;
	nb=filecabmegot.refroidis(nbminute,6,(4*60+40));//refroidis les megots et 
retourne la quantite de rangees froides
	nbrangeevide+=nb;
	megot-=36*nb;//Diminue le nombre de megot en entrepot
	return nb;
}


/************* CONSTRUCTEUR DE L'ELECTROLYSE *********************

Toutes la variables sont initialisees a zero sauf le taux d'utilisation des
anodes qui est determine par l'usager et la quatite	d'anode qui est de 100
au depart																													*/
electrolyse::electrolyse(double prodanodes):megot(0.0),anode(100.0),
			bennespleines(0.0),prodanode(prodanodes){}

/************************* ELECTROLYSE::AFFICHER 
*****************************/
void electrolyse::afficher(void) const{
	cout<<"Nombre de megots restants en electrolyse: "<<megot<<"\n";
	cout<<"Nombre d'anodes restants en electrolyse : "<<anode<<"\n";
	cout<<"Nombre de bennes pleines en electrolyse : "<<bennespleines<<"\n";
}

/************************* ELECTROLYSE::TRAVAILLE 
****************************

Cre des megots et des bennes pleines. Il faut envoyer ces megots en entrpot 
et
prendre des anodes. Il faut aussi envoyer les bennes pleines en entrepot
nbminute= pas de simulation
x= reference a l'entrepot																							 */
int electrolyse::travaille(int nbminute,entrepot & x)
{
	int cab, erreur,recoi=0;
	int reponse;
	megot=megot+(prodanode*nbminute)/60;//creation de megots
	anode=anode-(prodanode*nbminute)/60;//disparition des anodes
	bennespleines+=((prodanode*nbminute)/60)/6;//creation de bennes pleines
	if(anode<=0){				 //si anode est inferieur a 0, plus rien ne peut marcher
		anode+=(prodanode*nbminute)/60;
		megot-=(prodanode*nbminute)/60;
		cout<<"Il n'y a plus d'anode en electrolyse"<<"\n"<<endl;
		return 0;          //arret de la simulation
	}
	cab=(int)(megot)/6;
	envoitcab(cab,x);   //envoit les cabarets et diminue le nombre de megot
	recoi=recoitcab(cab,x);//recoit autant d'anodes que de megot envoyer
	if(recoi)
		recoitanode(x);
	bennespleines-=envoitbenne(x,nbminute);
	return 1;
}

/*************************** ELECTROLYSE::RECOITANODE 
***********************

Va chercher des anodes suplementaires si on est capable de les mettre en 
salle
d'electrolyse. On c'est di au depart qu'avoir 100 anodes etait un bon 
chiffre
nbminute=pas de simulation
x=reference a l'entrepot*/
void	electrolyse::recoitanode(entrepot& x){
	int i=0,cabrecu;
	int cab=(100-anode)/6;//nombre de cabaret d'anode qu'il pourrait manquer
	do{
		if(cab){
			cabrecu=recoitcab(1,x);//va chercher un cabaret
			if(cabrecu==1){
				i++;
				anode+=6;
			}
		}
	}while(i!=cab && cabrecu==1);//tant qu'il en manque
}

/********************** ELECTROLYSE::ENVOITBENNE ***************************

Envoit les bennes pleines a l'entrepot et retourne le nombre de bennes 
pleines
envoyer
x=reference a l'entrepot
nbminute-pas de simulation	*/
int electrolyse::envoitbenne(entrepot& x,int nbminute){
	int paquet,recu=0;
	paquet=(int)(bennespleines/2);
	recu=x.recoitbenne(paquet,nbminute);
	return recu;
}

/************************* ELECTROLYSE::ENVOITCAB **************************

Envoit les cabarets de megots en entrepot et diminue d'autant le nombre de
megot en electrolyse. Donne un message s'il n'y aplus de place pour stocker
les megots
nbcab:nombre de cabarets a envoyer
x:reference a l'entrepot 																										*/
void electrolyse::envoitcab(int nbcab,entrepot& x){
	int cab;
	cab=x.recoitcab(nbcab);//retourne le nombre de cabaret enfiles
	if(cab==-1){
		cout<<"il n'y a plus de place pour stoker les megots"<<endl;
		getch();
		cab=0;
	}
	megot=megot-cab*6;
}

/************************** ELECTROLYSE::RECOITCAB 
**************************

Recoit des cabarets d'anodes de l'entrepot et retourne le nombre de cabarets
recus
nbcab=nombre de cabarets desires
x=reference a l'entrepot																								*/
int electrolyse::recoitcab(int nbcab,entrepot& x){
	int cab;
	cab=x.envoitcab(nbcab);//retourne le nombre de cabaret envoyer par 
l'entrepot
	if(cab==-1)
		cab=0;
	anode+=6*cab;
	return cab;
}