/**********************************************************/
/*		Simulation																					*/
/**********************************************************/
#include <iostream.h>
#include <conio.h>
#include <stdlib.h>

class horloge
{
	private:
		long jour;
		long heure;
		long minute;
		long compteur;     //compte le nombre de pas de temps ‚coul‚
		double pas_temps;
	public:
		horloge(double pas_simulation);
		void temps_avance(void);
		void affiche_heure(void);
		long minute_ecoulee(void);
};




class entrepot
{
	private:
		int cabaret_anode;
		int cabaret_megot;
		int benne_vide;
		int benne_pleine;
		int nombre_rangee_cabaret;
		int nombre_rangee_benne;
		long * benne_temps;                 //pointeur sur les tableau
		int * benne_nombre;                 //de bennes et de cabarets
		int * benne_etat;
		long * cabaret_temps;
		int * cabaret_nombre;
		int * cabaret_etat;
		horloge & temps;
	public:
		entrepot(horloge & reference_temps, int nb_rangee_cab, int nb_rangee_ben,
					int nb_cabaret_anode, int nb_cabaret_megot, int nb_benne_vide);
		void affiche(void);
		int recevoir_cabaret(int nb_cabaret,int electrolyse);
		int envoyer_cabaret(int nb_cabaret,int electrolyse);
		int recevoir_benne(int nb_benne);
		int envoyer_benne(int nb_benne);
		void debug(void);
		void debug_cabaret(void);
};


class scellement
{
	private:
		double megots_scellement;
		double anodes_scellement;
		double taux_reparation_megot;
		double megots_repares;
		int megots_recus_total;
		int reception_megots;
		double temps_perdu;
		horloge & timer;
		entrepot & Engare;

	public:
		scellement(horloge & reference_temps, entrepot & entrepot_general, double tx_reparation);
		void travaille_scellement(double pas_simul);
		void affiche_scellement(void);

};


/*
class fonderie
{
	private:
		long lingot;

	public:
		fonderie(horloge & reference_temps);
		void travaille_fonderie(void);
		void affiche_fonderie(void);
*/



class electrolyse
{
	private:
		double megot;
		double anode;
		double taux_production_megot;
		double taux_production_benne;
		double benne_vide;
		double benne_pleine;
		double cabaret_megot;
		double cabaret_anode;
		entrepot & Engare;

//		double creuset_vide;
//		double creuset plein;



//	electrolyse(fonderie & fonderie_general, entrepot & entrepot_general , double tx_megot, double tx_benne);

	public:
		electrolyse(entrepot & entrepot_general , double tx_megot, double tx_benne);
		void travaille(void);
		void affiche(void);
};

/******************************************************************/
							/*	MAIN() */
/**********************************************************************/

void main(void)
{
	clrscr();

	double pas_simulation = 0.25;		 	  // Variable pour le pas de la simulation
	double taux_production_megot = 19.9;  // Variable pour le taux de production de megots
	double taux_production_benne=3.5;
	double taux_reparation_megot = 67.0;
	long i;                              	//compteur du nombre de pas ‚couler
	const long i_max = long (0.5*24/pas_simulation);    //i_max = jour*24heures*(1/pas_simulation)

	horloge TIMER(pas_simulation);
	entrepot E(TIMER, 10, 10, 54, 10, 36);
	electrolyse AL (E,(taux_production_megot * pas_simulation),(taux_production_benne * pas_simulation));
	scellement SCEL(TIMER, E, (taux_reparation_megot * pas_simulation));

			TIMER.affiche_heure();
			//SCEL.affiche_scellement();
			E.affiche();
			getch();


	for (i=0; i < i_max ; i++)
	{
		clrscr();
		TIMER.temps_avance();
		TIMER.affiche_heure();
		AL.travaille();
		AL.affiche();
		//SCEL.travaille_scellement(pas_simulation);
		//SCEL.affiche_scellement();
		E.affiche();

		getch();

	}
}
/**************************************************************/
					/*	salle_electrolyse 	*/
/**************************************************************/

/*constructeur electrolyse*/
//electrolyse::electrolyse(fonderie & fonderie_general, entrepot & entrepot_general, double taux_megot,double taux_benne) :
//	 La_fonderie(fonderie_general), Engare(entrepot_general),taux_production_megot(taux_megot),
//	 taux_production_benne(taux_benne), megot(0),anode(0),benne_vide(0),benne_pleine(0),cabaret_anode(0),cabaret_megot(0)



electrolyse::electrolyse(entrepot & entrepot_general, double taux_megot,double taux_benne) :
	 Engare(entrepot_general),taux_production_megot(taux_megot),
	 taux_production_benne(taux_benne), megot(0),anode(0),benne_vide(0),benne_pleine(0),cabaret_anode(0),cabaret_megot(0)
	 {
		cout <<"initialisation de la salle ‚lectrolyse"<<endl
				<< "megots = "<< megot << "   anodes =  "<< anode << endl;

	 }

/*Fonction salle_electrolyse travaille*/
void electrolyse:: travaille(void)
{
	int cabaret_plein_megot = 0;

	megot += taux_production_megot;
	anode -= taux_production_megot;
	cabaret_megot+= taux_production_megot/6.0;
	cabaret_anode-=taux_production_megot/6.0;

	benne_pleine += taux_production_benne;
	benne_vide -= taux_production_benne;

	//cout<< "nb megot avant de charger les cabaret (ELECTROLYSE) = "<< megot << endl;
	cout<< "nb cabaret_megot avant d'envoyer (ELECTROLYSE) = "<< cabaret_megot << endl;
	//cout<< "nb anode avant de recevoir cabaret (ELECTROLYSE) = "<< anode << endl;
	cout<< "nb cabaret_anode avant d'envoyer (ELECTROLYSE) = "<< cabaret_anode  << endl;
	cout<< "nb BENNE VIDE AVANT D'ENVOYER (ELECTROLYSE) = "<< benne_vide << endl;
	cout<< "nb BENNE PLEINE AVANT D'ENVOYER (ELECTROLYSE) = "<< benne_pleine << endl<<endl;

	//Chargement des cabaret de megots
	do
	{
		if (megot >= 6)
		{
			cabaret_plein_megot += 1;
			megot -= 6;
		}
	}while(megot >= 6);

	/* L'‚lectrolyse se d‚barsse des cabaret de m‚gots et demande
		des cabarets d'anodes */

	if(Engare.recevoir_cabaret(cabaret_plein_megot,1))
	{
		cabaret_megot -= cabaret_plein_megot;
	}
	else
	{
		cerr << "PROBLÔME D'ESPACE ENTREPOT (CABARET)";
		exit(1);
	}

	while(anode<=0)
	{
		if(Engare.envoyer_cabaret(1,1))
		{
			anode += 6;
			cabaret_anode+=1;
		}
		else           //j'ai tester ca ok
		{
			cerr << "MANQUE D'ANODE (ELECTROLYSE)" << endl;
			exit(1);
		}
	};


/* L'‚lectrolyse se d‚barsse des bennes pleines et demande
		des bennes vides */

	while(benne_pleine >= 2)
	{
		if(Engare.recevoir_benne(2))
		{
			benne_pleine -= 2;
		}
		else
		{
			cerr << "PROBLÔME D'ESPACE ENTREPOT(BENNE)";
			exit(1);
		}
	};

	while(benne_vide<=0)
	{
		if(Engare.envoyer_benne(2))
		{
			benne_vide += 2;
		}
		else           // j'ai tester ca ok
		{
			cerr << "MANQUE DE BENNE_VIDE (ELECTROLYSE)" << endl;
			exit(1);
		}
	};
}




/*Fonction salle_electrolyse affiche*/
void electrolyse::affiche()
{
		//cout << "Nombre de megots (ELECTROLYSE): " << megot << endl;
		//cout << "Nombre d'anodes (ELECTROLYSE): " << anode << endl;
		//cout << "Nombre de cabaret megot (ELECTROLYSE): " << cabaret_megot << endl;
		//cout << "Nombre de cabaret d'anode(ELECTROLYSE): " << cabaret_anode << endl;


}

/**************************************************************/
					/*	ENTREPOT 	*/
/**************************************************************/

/*constructeur entrepot*/
entrepot::entrepot(horloge & reference_temps, int nb_rangee_cab,
	int nb_rangee_ben, int nb_cabaret_anode, int nb_cabaret_megot,
	int nb_benne_vide) : temps(reference_temps)
{

	 nombre_rangee_benne=nb_rangee_ben;
	 nombre_rangee_cabaret=nb_rangee_cab;
	 cabaret_anode=nb_cabaret_anode;
	 cabaret_megot=nb_cabaret_megot;
	 benne_vide=nb_benne_vide;
	 benne_pleine=0;

	 //Cr‚ation et initialisation des tableaux de bennes

	 benne_nombre = new int [nombre_rangee_benne];
	 if(!benne_nombre)
	 {
			cerr << "PROBLEME DS TABLEAU DE BENNE "<< endl;
			exit(1);
	 }
	 benne_etat = new int [nombre_rangee_benne];
	 if(! benne_etat)
	 {
			cerr << "PROBLEME DS TABLEAU DE BENNE "<< endl;
			exit(1);
	 }
	 benne_temps = new long [nombre_rangee_benne];
	 if(! benne_temps)
	 {
			cerr << "PROBLEME DS TABLEAU DE BENNE "<< endl;
			exit(1);
	 }

	 for (int i = 0; i < nombre_rangee_benne; i++)
	 {
		benne_nombre[i]=0;
		benne_etat[i]=0;
		benne_temps[i]=0;
	 }

	 //Chargement des bennes vides dans l'entrepot

	 int rangee_ben=0;     // indice de la ranger de benne du tableau

	 while (nb_benne_vide)
	 {
			if (nb_benne_vide >14)
			{
				benne_nombre[rangee_ben]=14;
				nb_benne_vide -= 14;
			}
			else
			{
				benne_nombre[rangee_ben] = nb_benne_vide;
				nb_benne_vide = 0;
			}
			rangee_ben ++;

			if ((rangee_ben == nombre_rangee_benne-1) && (nb_benne_vide > 14))
			{
				cerr << "Trop de bennes vides pour le nombre de rangees en entrepot";
				exit(1);
			}
	 }
/*
	 debug();
	 getch();
	 cout <<endl;

	 for (int j = 0; j < 25; j++)
	 {
		temps.temps_avance();
		if(!recevoir_benne(2))
			cout << "probleme de benne pleine";
		debug();
		getch();
	 }

	 for (j = 0; j < 42; j++)
	 {
		temps.temps_avance();
	 }										//benne_temps[3]=1004;
	 cout<< temps.minute_ecoulee()<<endl;
	 getch();

	 for (int r = 0 ; r < 50; r++)
	 {
		if(!envoyer_benne(2))
			cout << "probleme de benne vide";
		debug();
		getch();
	 }

	for (j = 0; j < 200; j++)
	 {
		temps.temps_avance();
		if(!recevoir_benne(2))
			cout << "probleme de benne pleine";
		debug();
		getch();
	 }
*/

	 cabaret_nombre = new int [nombre_rangee_cabaret];
	 if(!cabaret_nombre)
	 {
			cerr << "PROBLEME DS TABLEAU DE CABARET "<< endl;
			exit(1);
	 }
	 cabaret_etat = new int [nombre_rangee_cabaret];
	 if(!cabaret_etat)
	 {
			cerr << "PROBLEME DS TABLEAU DE CABARET "<< endl;
			exit(1);
	 }

	 cabaret_temps = new long [nombre_rangee_cabaret];
	 if(!cabaret_temps)
	 {
			cerr << "PROBLEME DS TABLEAU DE CABARET "<< endl;
			exit(1);
	 }


	 for (i = 0; i < nombre_rangee_cabaret; i++)
	 {
			cabaret_nombre[i]=0;
			cabaret_etat[i]=0;
			cabaret_temps[i]=0;
	 }

	// debug_cabaret();
	// getch();

//Chargement des cabarets d'anodes dans l'entrepot
// cabaret_etat[i]=0 pour des cabarets_anodes

	 int rangee_cabaret=0;     // indice de la ranger de cabaret du tableau

	 while (nb_cabaret_anode)
	 {
			if (nb_cabaret_anode >6)
			{
				cabaret_nombre[rangee_cabaret]=6;
				nb_cabaret_anode -= 6;
				//cabaret_etat[rangee_cabaret]=0;
			}
			else
			{
				cabaret_nombre[rangee_cabaret] = nb_cabaret_anode;
				nb_cabaret_anode = 0;
			}
			rangee_cabaret ++;

			if ((rangee_cabaret == nombre_rangee_cabaret-1) && (nb_cabaret_anode > 6))
			{
				cerr << "Trop de cabarets anodes pour le nombre de rangees en entrepot";
				exit(1);
			}
		//	debug_cabaret();
		//	getch();
	 }


//Chargement des cabarets d'anodes dans l'entrepot
// cabaret_etat[i]=1 pour des cabarets_megots

	if(rangee_cabaret < nombre_rangee_cabaret)
	{
		while (nb_cabaret_megot)
		{
			if (nb_cabaret_megot > 6)
			{
				cabaret_nombre[rangee_cabaret] = 6;
				nb_cabaret_megot -= 6;
			}
			else
			{
				cabaret_nombre[rangee_cabaret] = nb_cabaret_megot;
				nb_cabaret_megot = 0;
			}
			cabaret_etat[rangee_cabaret] = 1;
			rangee_cabaret ++;

/*			//Petit problŠme ici
			if ((rangee_cabaret == nombre_rangee_cabaret) && (nb_cabaret_megot > 6))
			{
				cerr << "Trop de cabarets megot pour le nombre de rangees en entrepot";
				exit(1);
			} */
		}
	}

	else
		{
			cerr << "Trop de cabarets megot pour le nombre de rangees en entrepot";
			exit(1);
		}

//debug_cabaret();
//	 getch();

}
void entrepot::debug(void)
{
	cout << "Nombre :";
	for (int i = 0 ; i < nombre_rangee_benne ; i++)
	 cout<<benne_nombre[i] << " ";
	cout << endl << "Temps :";
	for (i = 0 ; i < nombre_rangee_benne ; i++)
	 cout<<benne_temps[i] << " ";
	cout << endl << "Etat :";
	for (i = 0 ; i < nombre_rangee_benne ; i++)
	 cout<<benne_etat[i] << " ";
	cout << endl << endl;
}

void entrepot::debug_cabaret(void)
{
	cout << "Nombre :";
	for (int i = 0 ; i < nombre_rangee_cabaret ; i++)
	 cout<<cabaret_nombre[i] << " ";
	cout << endl << "Temps :";
	for (i = 0 ; i < nombre_rangee_cabaret ; i++)
	 cout<<cabaret_temps[i] << " ";
	cout << endl << "Etat :";
	for (i = 0 ; i < nombre_rangee_cabaret ; i++)
	 cout<<cabaret_etat[i] << " ";
	cout << endl << endl;
}




/*	Fonction entrepot : affiche */

void entrepot::affiche(void)
{
	cout<<"nb cabarets de megots (ENTREPOT) = "<< cabaret_megot << endl;
	cout<<"nb cabarets d'anode (ENTREPOT) = "<< cabaret_anode << endl;
	cout<<"nb BENNE VIDE (ENTREPOT) = "<< benne_vide << endl;
	cout<<"nb BENNE PLEINE (ENTREPOT) = "<< benne_pleine << endl;
	//debug();

}

/*	Fonction entrepot : recevoir_cabaret */

int entrepot::recevoir_cabaret(int nb_cabaret, int electrolyse)
{
	if(electrolyse == 0)
	{
		cabaret_anode += nb_cabaret;
	}
	else
	{
		cabaret_megot += nb_cabaret;
	}

	return 1;
}



/*	Fonction entrepot : envoyer_cabaret */

int entrepot::envoyer_cabaret(int nb_cabaret, int electrolyse)
{
	if(electrolyse == 0)
	{
		if(cabaret_megot == 0)
		{
			cout << "il n'y a plus de cabaret de megots dans l'entrepot" <<endl;
			return 0;
		}
		else
		{
			cabaret_megot -= nb_cabaret;
		}
	}

	else
	{
		if(cabaret_anode == 0)
		{
			return 0;
		}
		else
		{
			cabaret_anode -= nb_cabaret;
		}
	}

	return 1;
}





/*	Fonction entrepot : recevoir_benne */
// etat benne: 0 vide 1 plein

int entrepot::recevoir_benne(int nb_benne)
{
	int r = -1;
	for (int i = nombre_rangee_benne-1 ; i>=0 ; i--)
	{
		if (((benne_etat[i]==0) && (benne_nombre[i]==0)) ||
			((benne_etat[i]==1) && (benne_nombre[i]<14)))
			r = i;
	}
	if (r==-1)
		return 0;

	benne_pleine += nb_benne;
	benne_nombre[r]+=nb_benne;
	benne_etat[r]=1;
	// V‚rifie si rangee pleine
	if (benne_nombre[r] == 14)
		benne_temps[r] = temps.minute_ecoulee();
	return 1;
}

/*	Fonction entrepot : envoyer_benne */

int entrepot::envoyer_benne(int nb_benne)
{
	int r = -1;
	for (int i = nombre_rangee_benne-1 ; i>=0 ; i--)
	{                                                      //Attention ici il y a un problŠme le 15 doit varier
		if (((benne_etat[i]==0) && (benne_nombre[i]>0)) ||
			((benne_etat[i]==1) && ((benne_temps[i]+(900-1)) < temps.minute_ecoulee()) && (benne_nombre[i]==14)))
			r = i;                                                                          //benne_nombre[i]==14
	}                                                                                    // benne_temps[i]!=0
	if (r==-1)
		return 0;

	// Si benne pleine, on convertit la rangee en benne vide
	if (benne_etat[r]==1)
	{
		benne_etat[r]=0;
		benne_temps[r]=0; //????????????
		benne_pleine-=14;
		benne_vide+=14;
	}

	benne_vide -= nb_benne;
	benne_nombre[r] -= nb_benne;

	//if (benne_nombre[r] == 0) // Si on vide la rangee de bennes vides, on reset le temps
	  //	benne_temps[r]=0;        //??????????????
	return 1;
}






/**************************************************************/
					/*	HORLOGE 	*/
/**************************************************************/

/* Constructeur de l'horloge */

horloge::horloge(double pas_simulation):jour(0), heure(0), minute(0),
	compteur(0), pas_temps(pas_simulation){}

/*	Fonction horloge :temps_avance  */

void horloge::temps_avance(void)
{
	double sum_heure;		 //nb heure ‚coull‚ depuis le d‚but de la simulation


	compteur++;
	sum_heure = double(compteur * pas_temps);
	jour =  long(sum_heure/24);
	heure = long(sum_heure - (jour * 24));
	minute = (sum_heure - (jour*24 + heure)) * 60;
}

/*	Fonction horloge : affiche_heure  */

void horloge::affiche_heure(void)
{
	cout << "\njour = " << jour <<" heure = " << heure <<" minute = "
			<< minute <<endl;
}

/*	Fonction horloge : minute_ecoulee */

long horloge::minute_ecoulee(void)
{
	return (long(compteur * pas_temps * 60));
}





/*************************************************************************/
/*					SALLE DE SCELLEMENT																					 */
/*************************************************************************/
scellement::scellement(horloge & reference_temps, entrepot & entrepot_general, double tx_reparation):
	timer(reference_temps), Engare(entrepot_general),
	taux_reparation_megot(tx_reparation), temps_perdu(0), megots_recus_total(0),
	reception_megots(0),megots_scellement(0), anodes_scellement(0),
	megots_repares(0) {}




/*	Fonction salle de scellement: travaille	*/
void scellement::travaille_scellement(double pas_simul)
{
	int ok = 0;
	double temps = (timer.minute_ecoulee() / 60.0);

	megots_recus_total = 0;

	if( (temps >=0.0 && temps<7.0) || (temps>=8.0 && temps<15.0) || (temps>=16.0 && temps<23.0) )
	{

		do
		{
			if(taux_reparation_megot > megots_scellement)
			{
				reception_megots = 0;
				reception_megots += (6 * Engare.envoyer_cabaret(1,0));
				megots_recus_total += reception_megots;

				if(reception_megots == 0)
				{
					cout << "Plus assez de megots dans la salle de scellement" <<endl;

					megots_repares = 0;
					temps_perdu += pas_simul;
					ok = 2;
				}
				else
				{
					megots_scellement += reception_megots;
				}
			}


			if(megots_scellement >= taux_reparation_megot)
			{
				megots_scellement -= taux_reparation_megot;
				megots_repares = taux_reparation_megot;
				anodes_scellement += taux_reparation_megot;

				ok = 1;
			}

		}while(ok == 0);


		do
		{
			if(anodes_scellement >= 6)
			{
				Engare.recevoir_cabaret(1,0);
				anodes_scellement -= 6;
			}
		}while(anodes_scellement >= 6);
	}

}


/*	Fonction salle de scellement: affiche	*/
void scellement::affiche_scellement(void)
{
	cout << endl<< "SALLE DE SCELLEMENT" << endl<<endl;
	cout << "        Megots : " << megots_scellement << endl;
	cout << "        Anodes : " << anodes_scellement << endl;
	cout << "  Megots recus : " << megots_recus_total << endl;
	cout << "   temps perdu : " << temps_perdu << endl;
	cout << "Megots repares : " << megots_repares << endl<<endl;

}




/******************************************************************/
/*				FONDERIE																								*/
/******************************************************************/
/*
fonderie(horloge & reference_temps): lingot (0)  {}


/*			Fonction fonderie: travaille			*/
/*void fonderie::travaille_fonderie(void)
{
*/