#include <iostream.h>
#include <conio.h>
int rancab,ranben,pas;
int er=0;
int besoincabaret;
int besoinbenne;

///////////////////     CLASSE DE TEMPS      //////////////////
class time {
private:
int heure;
int min;
public :
void avance1pas(void);
time(int HH,int MM);
int direheure(void);
};

time::time(int HH,int MM){   //constructeur qui fixe l'heure
heure=HH;min=MM;}

void time::avance1pas(void)   //avance l'horloge de 1 pas et avance l'heure
{
min=min+5;
if (min>=60) {min=min-60;heure++;}
if (heure==24) heure=0;
}

int time::direheure(void){   //fonction qui lit l'heure dans la partie privee
return heure;};


///////////////////////       ELECTROLYSE        ////////////////////////////////

class electrolyse{
private:
double cab_complet;                   //fraction de cabaret complete
double benne_complet;                 //fraction de benne complete
public:
void electrolyseGestion(void);        //fonction qui gere le debit d,entree/sortie
													//des bennes et cabarets
electrolyse::electrolyse(void);
};

electrolyse::electrolyse(void){       //constructeur
cab_complet=0;
benne_complet=0;
};

void electrolyse::electrolyseGestion(void){

besoincabaret=0;         ////met les flag de besoin par default a 0
besoinbenne=0;

cab_complet=cab_complet+0.276389; 					// somme du ratio de cabarets a entrer par pas. 19.9cab/h=0.276389/pas
if (cab_complet>=1){besoincabaret=1;// voir s'il est temps de rentrer et sortir cabaret
		cab_complet--;}               //si oui, le l'indiquer au main par ce flag

benne_complet=benne_complet+0.29167;             // somme du ratio de bennes a entrer par pas. 3,5/h=.29167/pas
if (benne_complet>=1){besoinbenne=1;// voir s'il est temps de rentrer et sortir benne
		benne_complet--;}             // si oui, le l'indiquer au main par ce flag

cout<<"\ncab_complet : "<<cab_complet<<"   benne_complete : "<<benne_complet<<"  \n";
cout<<"\nbesoin cabaret : "<<besoincabaret<<"   besoin benne : "<<besoinbenne<<"  \n";
};



/////////////////////////      FONDERIE     //////////////////////////
/* etant donne que quand la salle d'electrolyse fonctionne, nous avons un taux
constant d'entree de creuset, on a donc pas d'echange a tenir compte entre elle
et la fonderie.

*/
class fonderie{
private:
double creuset_complet;       // fraction de creuset complete
int NombreCreusetTraites;     // Nombre de Creusets Traites en ce moment dans la fonderie

public:
void fonderieGestion(void);   // fonction qui gere entree/sortie production de la fonderie
fonderie::fonderie(void);

};

fonderie::fonderie(void){     //constructeur
creuset_complet=0.001;     //(parce .333*3!= 1 mais .999 ce qui cause un mauvais processus
NombreCreusetTraites=0;};

void fonderie::fonderieGestion(void){
/////////////production de tonnes d'aluminium
creuset_complet=creuset_complet+0.333; // somme du ratio de creusets a entrer par pas.
if (creuset_complet>=1){	// si un creuset complet arrive de l'eletrolyse
		creuset_complet--;   //decremente la fraction de creuset complete de 1
		NombreCreusetTraites++;  // augmenter le nombre de creuset en traitement
		if (NombreCreusetTraites==7) //si le nombre de creuset=7 alors un creuset est terminer
												//car il a passe assez de temps dansla fonderie
		{cout<<"10 tonnes produites";  //indiquer que 10 tonnes viennent d'etre produites
		NombreCreusetTraites--;}      //diminuer de 1 le nombre de creusets en traitement
		}                             //car celui d'avant est sorti

		};



/////////////////////////    SELLEMENT   /////////////////////

class sellement{
private:
double cab_complet;       // fraction de cabaret complete

public:
sellement(void);
~sellement(void);
int sellementGestion(int heure);     //fonction gerant la salle de sellement
};

sellement::sellement(){cab_complet=0;}    //constructeur & destructeur
sellement::~sellement(){}

int sellement::sellementGestion(int heure){
int valret=0;                             //flag indiquant au main s'il faut renter et
														// sortir des cabaretsde megots et d'anodes
if ((heure!=7)&&(heure!=15)&&(heure!=23)) //execution du travail en dedans des
														//quarts de travail seulement.
  {
	 cab_complet=cab_complet+0.93056;            // somme du ratio de cabarets traites par pas.

	 if (cab_complet>=1)          //si un cabaret est complet?...
	 {valret=1;							//indique au main de rentrer et sortir cabaret
		cab_complet--;}            //baisse la fraction de 1 cabaret
	 }
	return valret;                //retourne le flag de l'ordre entree/sortie au main

	};

////////////////////        ENTREPOT       ///////////
/*   il est a noter que pour simplifier les choses, j'ai separe l'entrepot en
deux objets distincts soit entrepot pour bennes et cabaret. Ceci car malgre leur
similitudes de comportements, il n'ont pas un contenu pareil. En effet on a des
rangee qui n'ont pas la meme taille et le meme contenu etc.. .
*/

class entrepotbennes
{
	 private:
			int * typeRangee;
			int * NbBennes;
			int * TempsRefroid;
			int taille;
	 public:
			void afficher(void);
			entrepotbennes(int nbVoulu);
			~entrepotbennes(void);
			void placerbenne(void);
			void prendrebenne(void);
			void refoidirbenne(void);
			void placerbennevide(int nombre);
			};


////////// construit l'entrepot de bennes ///////////
/////constructeur qui declare les rangee selon le nb voulu de rangee

entrepotbennes::entrepotbennes(int nbVoulu){
	if (nbVoulu > 0) {
		typeRangee = new int[nbVoulu];     //case pour type de rangee
		NbBennes = new int[nbVoulu];       //case pour Nombre de bennes contenue
		TempsRefroid = new int[nbVoulu];}; //case pour temps de refroidissement restant
	for (int i=0;i<nbVoulu;i++){ 			  //initialise toutes les cases a 0/////
		typeRangee[i]=0;
		NbBennes[i]=0;
		TempsRefroid[i]=0;
		}
	taille=nbVoulu;
	};

////////destructeur d'entrepot de bennes, detruit les tableaux
entrepotbennes::~entrepotbennes(void) {
	if (typeRangee) delete[] typeRangee;
	if (NbBennes) delete[] NbBennes;
	if (TempsRefroid) delete[] TempsRefroid;
}

/////fonction d'affichage du contenu des cases

void entrepotbennes::afficher(void){
int i=0;
cout<<"\n\netat des rangees de bennes\n";
for (i=0;i<taille;i++){cout<<" "<<i;};
cout<<"\nType de rangee (0-benne chaude 1-refroidir 2-bennes froides) :\n";
for (i=0;i<taille;i++){if (i>10) cout<<" ";cout<<" "<<typeRangee[i];}
cout<<"\nNombre de bennes places dedans:\n";
for (i=0;i<taille;i++){if (i>10) cout<<" ";cout<<" "<<NbBennes[i];}
cout<<"\nTemps de refroidissement restant en min :\n";
for (i=0;i<taille;i++){if (i>10) cout<<" ";cout<<" "<<TempsRefroid[i]*5/pas;}
};


//////fonction qui place une bennne chaude/////

void entrepotbennes::placerbenne(void){
int i=0;
er=1;
for (i=0;i<taille;i++){       //cherche un rangee ou l'on peut placer une benne
	if (typeRangee[i]==0){     // si type de rangee = 0 (pour placer benne
		NbBennes[i]++;          // on rajoute une benne
		if (NbBennes[i]==14){   // s'il y a alors 14 bennes

		typeRangee[i]++;        //le type de rangee chage pour une rangee en refroidissement
		TempsRefroid[i]=180;    //On fixe le nombre de pas que va refroidir cette rangee
		};                      //des que la benne est placee, on stoppe la routine
		er=0;break;};
	};

//message d'erreur, impossible de fournir la requete
if (er) {cout<<"Impossible de placer une benne dans l'entrepot!!!\nVeuillez appuyer sur une touche pour continuer...";
getch();};


};


// cette fonction ne sert qu'au debut quand on veut placer dans l'entrepot les
//bennes prete a etre utilisee

void entrepotbennes::placerbennevide(int nombre){
int i=0,v=0;


for (v=0;v<nombre;v++){
for (i=0;i<taille;i++){
	if (typeRangee[i]==0){
		NbBennes[i]++;
		if (NbBennes[i]==14){

		typeRangee[i]=2;
		};
		break;};
	}};


for (i=0;i<taille;i++){
	if ((typeRangee[i]==0)&&(NbBennes[i]>0)) typeRangee[i]=2;
	};


};

//fonction qui permet de retirer une benne de l'entrepot pour l'electrolyse

void entrepotbennes::prendrebenne(void){

int i=0;
er=1;
for (i=0;i<taille;i++){
	if (typeRangee[i]==2){
		NbBennes[i]--;
		if (NbBennes[i]==0){

		typeRangee[i]=0;
		};
		er=0;break;};
	};
//message d'erreur, impossible de fournir la requete
if (er) {cout<<"Impossible de prendre une benne dans l'entrepot!!!\nVeuillez appuyer sur une touche pour continuer...";
getch();};

};

//fonction qui permet de refroidir une rangee de bennes de l'entrepot

void entrepotbennes::refoidirbenne(void){
int i=0;
for (i=0;i<taille;i++){
	if (typeRangee[i]==1){
		TempsRefroid[i]--;
		if (TempsRefroid[i]==0){
		typeRangee[i]=2;
		};};
	};
};





//entrepot cabaret
class entrepotcabaret
{
	 private:
			int * typeRangee;
			int * Nbcabaret;
			int * TempsRefroid;
			int taille;
	 public:
			void afficher(void);
			entrepotcabaret(int nbVoulu);
			~entrepotcabaret(void);
			void placercabaretmegot(void);
			void placercabaretmegotfroid(int nombre);
			void prendrecabaretmegot(void);
			void refoidircabaretmegot(void);
			void placercabaretanode(void);
			void prendrecabaretanode(void);
			};


////////// construit l'entrepot de cabaret ///////////
entrepotcabaret::entrepotcabaret(int nbVoulu){
	if (nbVoulu > 0) {
		typeRangee = new int[nbVoulu];     /////declare les rangee selon le nb voulu
		Nbcabaret = new int[nbVoulu];
		TempsRefroid = new int[nbVoulu];};
	for (int i=0;i<nbVoulu;i++){ /////////////initialise toutes a 0/////
		typeRangee[i]=0;
		Nbcabaret[i]=0;
		TempsRefroid[i]=0;
		}
	taille=nbVoulu;
	};

////////destructeur d'entrepot de cabaret /////////
entrepotcabaret::~entrepotcabaret(void) {
	if (typeRangee) delete[] typeRangee;
	if (Nbcabaret) delete[] Nbcabaret;
	if (TempsRefroid) delete[] TempsRefroid;
}


void entrepotcabaret::afficher(void){
int i=0;
cout<<"\n\netat des rangees de cabaret\n";
for (i=0;i<taille;i++){cout<<" "<<i;};
cout<<"\nType de rangee (0-megot chauds 1-refroidir megot \n2-megot froid 3-anode 4-pleine d'anode) :\n";
for (i=0;i<taille;i++){if (i>10) cout<<" ";cout<<" "<<typeRangee[i];}
cout<<"\nNombre de cabaret places dedans:\n";
for (i=0;i<taille;i++){if (i>10) cout<<" ";cout<<" "<<Nbcabaret[i];}
cout<<"\nTemps de refroidissement (en pas) restant en min :\n";
for (i=0;i<taille;i++){if (i>10) cout<<" ";cout<<" "<<TempsRefroid[i];}
};

////fonction qui permet de placer un cabaret de megot dans l'entrepot par l'electrolyse

void entrepotcabaret::placercabaretmegot(void){
int i=0;
er=1;
for (i=0;i<taille;i++){
	if (typeRangee[i]==0){
		Nbcabaret[i]++;
		if (Nbcabaret[i]==6){

		typeRangee[i]++;
		TempsRefroid[i]=48;
		};
		er=0;break;};
	};

//message d'erreur, impossible de fournir la requete
if (er) {cout<<"Impossible de placer un cabaret de megots dans l'entrepot!!!\nVeuillez appuyer sur une touche pour continuer...";
getch();};

};

/////
// cette fonction ne sert qu'au debut quand on veut placer dans l'entrepot les
//cabaret de megots froids prets a etre traites

void entrepotcabaret::placercabaretmegotfroid(int nombre){
int i=0,v=0;

for (v=0;v<nombre;v++){
for (i=0;i<taille;i++){
	if (typeRangee[i]==0){
		Nbcabaret[i]++;
		if (Nbcabaret[i]==6){

		typeRangee[i]=2;
		};
		break;};
	}};

for (i=0;i<taille;i++){
	if ((typeRangee[i]==0)&&(Nbcabaret[i]>0)) typeRangee[i]=2;
	};

};



////fonction qui permet de prendre un cabaret de megot dans l'entrepot par l'electrolyse

void entrepotcabaret::prendrecabaretmegot(void){
int i=0;
er=1;
for (i=0;i<taille;i++){
	if (typeRangee[i]==2){
		Nbcabaret[i]--;
		if (Nbcabaret[i]==0){
		typeRangee[i]=0;
		};
		er=0;break;};
	};

	//message d'erreur, impossible de fournir la requete
if (er) {cout<<"Impossible de prendre un cabaret de megots dans l'entrepot!!!\nVeuillez appuyer sur une touche pour continuer...";
getch();};
};

////fonction qui permet de refroidir un cabaret de megot dans l'entrepot

void entrepotcabaret::refoidircabaretmegot(void){
int i=0;
for (i=0;i<taille;i++){
	if (typeRangee[i]==1){
		TempsRefroid[i]--;
		if (TempsRefroid[i]==0){
		typeRangee[i]=2;
		};};
	};
};

////////////cabarets d'anodes////////////
//fonction qui permet de placer un cabaret d'anode dans l'entrepot par l'electrolyse
//la logique de cette fonction est un exploit


void entrepotcabaret::placercabaretanode(void){
int i=0,flag=0;
er=1;
for (i=0;i<taille;i++){   //cherche une rangee qui sert a stocker cabaret anode
	if (typeRangee[i]==3){flag=1;};}; //si elle existe ok, on pourra les placer plus loin
if (!flag) {    //si elle n'existe pas...
	for (i=0;i<taille;i++){
		if ((typeRangee[i]==0)&&(Nbcabaret[i]==0)) //on cherche alors une rangee libre
		{typeRangee[i]=3;er=0;break;};   //puis on la cree
		};
};

for (i=0;i<taille;i++){
	if (typeRangee[i]==3){   //on trouve une rangee qui sert a stocker anodes
		Nbcabaret[i]++;        //on l'incremente de 1 cabaret d'anode
		if (Nbcabaret[i]==6){    //si cela = 6 la rangee devra etre vide

		typeRangee[i]++;   //son type de rangee est alors 4 soit pleine d'anodes
		};
		er=0;break;};
	};

	//message d'erreur, impossible de fournir la requete
if (er) {cout<<"Impossible de placer un cabaret d'anodes dans l'entrepot!!!\nVeuillez appuyer sur une touche pour continuer...";
getch();};

};


void entrepotcabaret::prendrecabaretanode(void){
int i=0;
er=1;
// on cherche d'abord a vider les rangee de cabaret d'anodes pleines soit de type 4


for (i=0;i<taille;i++){
	if (typeRangee[i]==4){
		Nbcabaret[i]--;
		if (Nbcabaret[i]==0){

		typeRangee[i]=0;
		};
		er=0;break;};
	};
// sinon on vide de 1 cabaret un rangee pas encore remplie

	for (i=0;i<taille;i++){
	if (typeRangee[i]==3){
		Nbcabaret[i]--;
		if (Nbcabaret[i]==0){

		typeRangee[i]=0;
		};
		er=0;break;};
	};

	//message d'erreur, impossible de fournir la requete
if (er) {cout<<"Impossible de prendre un cabaret d'anodes dans l'entrepot!!!\nVeuillez appuyer sur une touche pour continuer...";
getch();};

};



////////////main()/////////////////////////////////////




void main (void){
int cabano,cabmeg,benvid,duree;
int i,v;
cout<<"Nb de rangees de cabarets disponibles dans l'entrepot? :";
cin>>rancab;
cout<<"\nNb de rangees de bennes disponibles dans l'entrepot? :";
cin>>ranben;
cout<<"\nNb de cabarets d'anodes au depart dans l'entrepot ? :";
cin>>cabano;
cout<<"\nNb de cabarets de megots froid au depart dans l'entrepot ? :";
cin>>cabmeg;
cout<<"\nNb de bennes vides au depart dans l'entrepot ? :";
cin>>benvid;
cout<<"\nQuel est le pas (1=5min,2=10min,3=15min)? ";
cin>>pas;
cout<<"\nQuel est la duree de la simulation en pas? ";
cin>>duree;
cout<<"Cette simulation est pour une production de 40 tonnes/h....\n\n\n";
entrepotbennes ranbennes(ranben);///initialise l'entrepot des bennes
entrepotcabaret rancabaret(rancab);///initialise l'entrepot des cabaret

ranbennes.placerbennevide(benvid);///mettrebennes vides dans entrepot
rancabaret.placercabaretmegotfroid(cabmeg); //placer les cabaret de depart
for (i=0;i<cabmeg;i++){rancabaret.placercabaretanode();}; //dans l'entrepot de cabaret

//////////////////affichage du contenu///////////////
cout<<"Etat des chose au debut...\n";
ranbennes.afficher();   //donner une idee du contenu de depart des rangee des entrepot
rancabaret.afficher();
getch();


/////////note : ne pas oublier de faire refroidire les bennes et megots
time temps(0,0); ///met l'heure a 0h
sellement sallesellement;
electrolyse salleelectrolyse;//////debut de la simulation
fonderie sallefonderie;


int valret;
rancabaret.prendrecabaretmegot(); ////////sellement
rancabaret.prendrecabaretanode();////////electrolyse
ranbennes.prendrebenne();       ///////"""""""""""""/////////

///////on fait runner le tout selon le nombre de pas
for (i=0;i<duree;i++){
for (v=0;v<pas;v++){

///////////electrolyse////////
salleelectrolyse.electrolyseGestion();
if (besoincabaret) {rancabaret.prendrecabaretanode();rancabaret.placercabaretmegot();}
if (besoinbenne) {ranbennes.prendrebenne();ranbennes.placerbenne();}


//sellement...
valret=sallesellement.sellementGestion(temps.direheure());
if (valret){rancabaret.placercabaretanode();rancabaret.prendrecabaretmegot();};
valret=0;

//fonderieGestion();
sallefonderie.fonderieGestion();

///////////////////////
temps.avance1pas();
rancabaret.refoidircabaretmegot();
ranbennes.refoidirbenne();
}

///////affichage a chaque pas
ranbennes.afficher();
rancabaret.afficher();
cout<<"\n Appuyez sur une touche pour le pas suivant...";
getch();
clrscr();
}
//fin
cout<<"Simulation terminee, esperons que vous vous etes amuses plus longtemps\n que le temps que cela nous a pris pour mettre au point cette simulation!\n";

};