/* 
	Par Mercier, Bedard et Associés.
*/


#include <stdio.h>
#include <conio.h>
#include <iostream.h>
#include <math.h>
#include <stdlib.h>
#include <dos.h>

class Pile;
class File;
class Entrepot;
class Electrolyse;
class Scellement;
class Fonderie;


//**************************************************************************************************

class Pile {
	private:
		long * tab;							// tableau qui constitue la pile

		long haut;							// la haut de la pile
		long compteur;						// compteur de delai pour le temps de refroidissement
		long delai;							// variable de temps de refroidissement
	public:
		long taille;						// taille de la pile
		Pile(void);							// constructeur
		Pile(long nbVoulu);					// constructeur avec spécification de la taille voulue
		Pile(long nbVoulu, long delai);		// constructeur avec taille voulue et temps refroidissement
		~Pile(void);						// desctructweur du tableau dynamique
		int ajoute(long valeur);			// fct qui ajoute un element dans la pile
		int enleve(long & valeur);			// fct qui enleve un element dans la pile
		int pileVide(void);					// comparaison qui verifie si la pile est vide
		int pilePleine(void);				// comparaison qui verifie si la pile est pleine
		void ajoutePas(int dureePas);		// fct qui ajoute le pas
		void resetCompteur(void);			// fct qui remet le compteur de temps a zero
		int pileFroide(void);				// comparaison qui verifie si la pile est froide
};

Pile :: Pile(void) {
	taille = 0;
	tab = 0;
	haut = -1;
	compteur = 0;
	delai = 900;
}

Pile :: Pile(long nbVoulu) {
	taille = 0;
	tab = 0;
	haut = -1;
	compteur = 0;
	delai = 900;
	if(nbVoulu > 0)
	{
		tab = new long[nbVoulu];
		if(tab)
		{
			taille = nbVoulu;
		}
	}
}

Pile :: Pile(long nbVoulu, long delai) {
	taille = 0;
	tab = 0;
	haut = -1;
	compteur = 0;
	this -> delai = delai;
	if(nbVoulu > 0)
	{
		tab = new long[nbVoulu];
		if(tab)
		{
			taille = nbVoulu;
		}
	}
}

Pile :: ~Pile(void)
{
	if (tab)
		delete [] tab;
	cout << "Destroy!!!" << endl;
}

void Pile::ajoutePas(int dureePas) {

	compteur += dureePas;
}

void Pile::resetCompteur(void) {
	compteur = 0;
}

int Pile::pileFroide(void) {
	return (pilePleine() && (compteur >= delai));
}

int Pile :: pileVide(void) {
	return (haut == -1);
}

int Pile :: pilePleine(void) {
	if (haut == -1)
		return 0;
	else
		return (haut == (taille - 1));
}

int Pile :: ajoute(long valeur) {
	if(pilePleine())
	{
		cout << "\nincapable d'ajouter...";
		return 0;
	}
	haut++;
	tab[haut] = valeur;
	return 1;
}

int Pile :: enleve(long &valeur) {
	if(pileVide())
	{
		cout << "\nincapable d'enlever..";
		return 0;
	}
	valeur = tab[haut];
	haut--;
	return 1;
}

//**************************************************************************************************

class File {
	private:
		long * tab;						// tableau qui constitue la file
		long taille;					// variable indiquant la taille de la file
		long longueurFile;				// variable indiquant la longueur de la file
		long devant;					// variable indiquant le devant de la file
		long derriere;					// variable indiquant le derriere de la file
		void enleveDevant(void);		// enleve une place devant
		void ajouteDerriere(void);		// ajoute une place derriere

	public:
		File(long nbVoulu);				// constructeur avec la taille voulue
		~File(void);					// destructeur de la file
		int enfile(long valeur);		// fct qui ajoute un element dans la file
		int defile(void);				// fct qui enleve un element dans la file
		int fileVide(void);				// fct qui verifie si la file est vide
		long getTaille(void);			// fct qui retourne la taille de la file
		long getElement(long noElement);// fct qui retourne l'element a la position specifiee
		int filePleine(void);			// fct qui verifie si la file est pleine
};

File :: File(long nbVoulu){
	taille = 0;
	tab = 0;
	longueurFile = 0;
	devant = -1;
	derriere = -1;
	if(nbVoulu > 0)
	{
		tab = new long [nbVoulu];
		if (tab)
		{
			taille = nbVoulu;
			for (int i = 0; i < nbVoulu; i++)
				tab[i] = -1;
		}
	}
}

File :: ~File(void){
	if (tab)
		delete [] tab;
	cout << "DESTROY LA FILE!!!" << endl;
}

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

long File :: getTaille(void) {
	return taille;
}

int File :: filePleine(void) {
//	cout << "Devant: " << devant << " Derriere: " << derriere << endl;
	if (devant == 0 && derriere == (taille - 1))
		return 1;
	else if (!fileVide())
		return ((devant - 1 ) == derriere);
	else
		return 0;
}

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

void File :: ajouteDerriere(void){
	longueurFile++;
	derriere  = (derriere + 1) % taille;
}

int File :: enfile(long valeur){
	ajouteDerriere();
	if (derriere == devant)
	{
		cout << "\nprobleme avec enfile";
		return 0;
	}
	cout << "Enfile: " << valeur << endl;
	tab[derriere] = valeur;
	if (longueurFile == 1)
		devant = derriere;
	return 1;
}

int File :: defile(void){
	if(! fileVide())
	{
		long elem = tab[devant];
		enleveDevant();
		return elem;
	}
	cout << "\nprobleme avec defile";
	return 0;
}

long File :: getElement(long noElement) {

	if (noElement < taille)
		return tab[noElement];
	else
	{
		cout << "Element hors du tableau" << endl;
		return -1;
	}

}


//**************************************************************************************************

class Fonderie {
	private :
		File fileCoulee;
		int nbCreusets;
		long temps;
		long identificateur;
		int dureePas;
	public :
		Fonderie(int dureePas);
		void travaille(void);
		void recoitcreuset(int nbCreuset);
		void setDureePas(int dureePas);
};


Fonderie::Fonderie(int dureePas):fileCoulee(6) {
	int tmpGrandeurFile;
	
	this -> dureePas = dureePas;

	switch(dureePas) {
		case (15): tmpGrandeurFile = 6;
				   nbCreusets = 9;	
				   break;
		case (10): tmpGrandeurFile = 9;
				   nbCreusets = 12;
				   break;
		case (5):  tmpGrandeurFile = 18;
				   nbCreusets = 21;
				   break;
	}
	fileCoulee = File(tmpGrandeurFile);
	identificateur = 0;
	temps = 0;
}

void Fonderie::travaille(void) {

	if (fileCoulee.filePleine())
		fileCoulee.defile();

	fileCoulee.enfile(identificateur % nbCreusets);

	cout << "Creuset en cours: " << (identificateur % nbCreusets) << " Identificateur: " << identificateur << endl;
	cout << "Nb Creusets: " << nbCreusets << " Ordre des creusets: ";

	for (int i = 0; i < fileCoulee.getTaille(); i++)
		cout << fileCoulee.getElement(i) << " ";
	cout << endl;

	identificateur++;
}

void Fonderie::setDureePas(int dureePas) {
	this -> dureePas = dureePas;
}

//**************************************************************************************************

class Entrepot {
	private:
		int nbBenRangee;		// Nombre de rangees de bennes
		int nbCabRangee;		// Nombre de rangees de cabarets
		Pile * rangeesC;		// Tableau de piles(rangees) de cabarets
		Pile * rangeesB;		// Tableau de piles(rangees) de bennes
		double nbMegots;		// Nombre de mégots
		double nbAnodes;		// Nombre d'anodes
		int nbRangeesB;			// Nombre de rangees de bennes dans l'entrepot
		int nbRangeesC;			// Nombre de rangees de cabarets dans l'entrepot
		double nbBennesVides;	// Nombre de bennes
		int capCabaret;			// Nombre de megots ou d'anodes par cabaret
		int dureePas;			// Duree du pas de simulation(dependant de la qte de production)
		double qteCroute;		// Quantite de croute (en terme de bennes)
		long temps;				// Variable du temps
	public:
		Entrepot(int dureePas, int nbRangeesB, int nbRangeesC, double nbMegots, double nbAnodes, double nbBennesVides);
		~Entrepot(void);						// Destructeur de l'entrepot
		double donneAnodes(double nbVoulu);		// Fct qui envoie des anodes a la salle electrolyse
		double donneMegots(void);				// Fct qui envoie des megots a la salle de scellement
		void recoitAnodes(double nbDonne);		// Fct qui recoit des anodes de la salle de scellement
		void recoitCroute(int nbDonne);			// Fct qui recoit des bennes de croute
		void setDureePas(int dureePas);			// Fct qui implante la duree du pas a l'entrepot
		void travaille(void);					// Fct qui fait travailler l'entrepot
};

Entrepot::Entrepot(int dureePas, int nbRangeesB, int nbRangeesC, double nbMegots, double nbAnodes, double nbBennesVides) {

	int i = 0;

	this -> nbRangeesB = nbRangeesB;
	this -> nbRangeesC = nbRangeesC;
	this -> nbMegots = nbMegots;
	this -> nbAnodes = nbAnodes;
	this -> nbBennesVides = nbBennesVides;

	this -> dureePas = dureePas;
	temps = 0;
	capCabaret = 6;
	nbBenRangee = 14;
	nbCabRangee = 6;
	qteCroute = 0;

	rangeesB = new Pile[nbRangeesB];
	rangeesC = new Pile[nbRangeesC];

	for (i = 0; i < nbRangeesB; i++)
		rangeesB[i] = Pile(nbBenRangee, 900);

	for (i = 0; i < nbRangeesC; i++)
		rangeesC[i] = Pile(nbCabRangee, 240);


}

Entrepot::~Entrepot(void) {
	if (rangeesC)
		delete [] rangeesC;
	if (rangeesB)
		delete [] rangeesB;
}

	/* Cette fonction echange des anodes contre des megots.
	   L'echange se fait en termes d'anodes et de megots, et non de cabarets.
	   Il revient donc a chaque salle de calculer le nombre d'items a transferer
	   en fonction de la capacite des cabarets. */

void Entrepot::setDureePas(int dureePas) {
	this -> dureePas = dureePas;
}

double Entrepot::donneAnodes(double nbVoulu)
{
	double tmpValeurRetour;

	/* S'il n'y a pas assez d'anodes, l'entrepot envoie le maximum de "cabarets"
	   qu'elle peut. */

	if(nbVoulu > (nbAnodes))	// Nb anodes insuffisant
	{
		double tmpNbAnodes = nbAnodes; // variable tampon
		nbAnodes -= ((int) (nbAnodes / capCabaret)) * capCabaret;
		nbMegots += ((int) (tmpNbAnodes / capCabaret)) * capCabaret;
//		cout << "Pas assez... nb d'anodes donnees : " << ((int) (tmpNbAnodes / capCabaret)) * capCabaret << "\n";
		tmpValeurRetour = ((int) (tmpNbAnodes / capCabaret)) * capCabaret;
	}
	else						// Nb anodes suffisant
	{
//		cout << "Test... Entrepot (avant) -> Anodes: " << nbAnodes << " Megots: " << nbMegots << endl;
		nbAnodes -= nbVoulu;
		nbMegots += nbVoulu;
//		cout << "Test... Entrepot (apres) -> Anodes: " << nbAnodes << " Megots: " << nbMegots << endl;
//		cout << "En veux-tu, en v'la... nb d'anodes donnees : " << nbVoulu << "\n";
		tmpValeurRetour = nbVoulu;
	}

	/* On place nos mégots dans des rangées */

//	cout << "Nombre de rangees de cabarets: " << nbRangeesC << endl;
	for (int i = 0; i < nbRangeesC; i++)
	{
//		cout << "\tRangee pleine?: " << rangeesC[i].pilePleine() << endl;
//		cout << "\tNb Assez de megots?: " << (nbMegots > capCabaret) << endl;
//		cout << "\tTaille de la rangee: " << rangeesC[i].taille << endl;
		while (!rangeesC[i].pilePleine() && nbMegots > capCabaret)
		{
			nbMegots -= capCabaret;
//			cout << "\tRangement dans la rangee " << i << endl;
			rangeesC[i].ajoute(temps);
		}
	}

	cout << "Entrepot (Shipping) -> Demande: " << nbVoulu << " Envoye: " << tmpValeurRetour << " Anodes"<< endl;
	return tmpValeurRetour;
}

	/* Cette fonction renvoit tous les megots disponibles au demandeur,
	   soit les megots refroidis des rangees pleines. */

double Entrepot::donneMegots(void)
{
	double tmpNbMegots = 0;
	long tmpTemps;

	for (int i = 0; i < nbRangeesC; i++)
	{
		if (rangeesC[i].pileFroide())
		{
			while (!rangeesC[i].pileVide())
			{
				tmpNbMegots += capCabaret;
				rangeesC[i].enleve(tmpTemps);
			}
			rangeesC[i].resetCompteur();
		}
	}
	cout << "Entrepot -> Megots prets et envoyes: " << tmpNbMegots << endl;
	return tmpNbMegots;
}

void Entrepot::recoitAnodes(double nbDonne) {
	cout << nbDonne << " Anodes recues" << endl;
//	cout << "Test... Entrepot -- Reception (avant) -> Anodes: " << nbAnodes << " Megots: " << nbMegots << endl;
	nbAnodes += nbDonne;
//	cout << "Test... Entrepot -- Reception (apres) -> Anodes: " << nbAnodes << " Megots: " << nbMegots << endl;
}

void Entrepot::recoitCroute(int nbDonne) {

	cout << "Entrepot -> Croute recue: " << nbDonne << endl;
	cout << "Nb bennes vides: " << nbBennesVides << endl;
	if (nbBennesVides >= nbDonne)
		nbBennesVides -= nbDonne;
	else
	{
		cout << "Erreur!!! Il manque " << (nbDonne - nbBennesVides) << " benne(s) vide(s)." << endl;
		exit(0);
	}

	qteCroute += nbDonne;

	for (int i = 0; i < nbRangeesB; i++)
	{
		while (!rangeesB[i].pilePleine() && qteCroute)
		{
			qteCroute--;
			rangeesB[i].ajoute(temps);
		}
	}
	cout << "Entrepot -> Croute recue: " << nbDonne << " Restante: " << qteCroute << endl;
}

void Entrepot::travaille(void) {
	long tmpTemps;
	int i;
	temps += dureePas;

	for (i = 0; i < nbRangeesC; i++)
		if (rangeesC[i].pilePleine())
			rangeesC[i].ajoutePas(dureePas);

	for (i = 0; i < nbRangeesB; i++)
	{
		if (rangeesB[i].pilePleine())
			rangeesB[i].ajoutePas(dureePas);
		if (rangeesB[i].pileFroide())
		{
			while (!rangeesB[i].pileVide())
				rangeesB[i].enleve(tmpTemps);

			rangeesB[i].resetCompteur();
			nbBennesVides += nbBenRangee;
			cout << "Rangee: " << i << " videe" << endl;
//			getch();
		}
	}			
}

//**************************************************************************************************

class Electrolyse {
	private :
		int capCabaret;	// nombre de megots ou d'anodes par cabaret
		double tauxAbase; // taux d'usure des anodes
		double tauxA;			// taux d'usure des anodes
		double nbMegots;    	// nombre de megots
		double nbAnodes;    	// nombre d'anodes
		double qteCroute;		// quantite de croute (en terme de bennes)
		double tauxB;			// taux de sortie des bennes
		double nbBennesV;		// nombre de bennes vides
		double nbBennesP;		// nombre de bennes pleines
		int dureePas;			// duree du pas de simulation
		long temps;
		Entrepot & salleEnt;
		Fonderie & salleFond;
	public :
		Electrolyse(int dureePas, double nbBenneV, Entrepot & salleEntx, Fonderie & salleFondx);
		int getDureePas(void);
		void travaille(void);


};

Electrolyse::Electrolyse(int dureePas, double nbBennesV, Entrepot & salleEntx, Fonderie & salleFondx)
														 : salleEnt(salleEntx), salleFond(salleFondx)
{
	//faire un "dureePas de base"
	tauxAbase = 19.9;
	capCabaret = 6;
	this -> dureePas = dureePas;

	switch(dureePas)
	{
		case (15):
			tauxA = 19.9;
			break;
		case (10):
			tauxA = 15/10 * tauxAbase;
			break;
		case (5):
			tauxA = 15/5 * tauxAbase;
			break;
		default :
			tauxA = 19.9;
	}

	this -> nbBennesV = nbBennesV;
	nbBennesP = 0;
	tauxB = 3.5;
	nbMegots = 0;
	nbAnodes = 100;
	qteCroute = 0;
	temps = 0;
}

int Electrolyse::getDureePas(void) {
	return dureePas;
}

void Electrolyse::travaille(void)
{
	double nbAnodesRecues;

	temps += dureePas;

	nbAnodes -= tauxA/(60/dureePas);	// usage des anodes
	nbMegots += tauxA/(60/dureePas);	// creation de megots
	qteCroute += tauxB/(60/dureePas);	// creation de croute

//	cout << "Nb Anodes:" << nbAnodes << "\tNb Megots: " << nbMegots << "\tNb Cabarets envoyes: " << ((int) (nbMegots / capCabaret)) << "\nTemps: " << temps << "\n";
//	cout << "Electrolyse (Shipping) -> " << ((int) (nbMegots / capCabaret)) * capCabaret << " Anodes" << endl;
	nbAnodesRecues = salleEnt.donneAnodes(((int) (nbMegots / capCabaret)) * capCabaret);

	if(nbAnodesRecues < ((int) (nbMegots / capCabaret)) * capCabaret)
	{
		cout << "erreur!!! erreur!!! manque d'anodes!!!\n";
		getch();
		exit (0);
	}
	else
	{
		nbAnodes += nbAnodesRecues;
		nbMegots -= nbAnodesRecues;
	}

	salleEnt.recoitCroute((int) (qteCroute / 2));
	qteCroute -= (int) (qteCroute / 2);

	cout << "Electrolyse -> Nb Anodes:" << nbAnodes << "   Nb Megots: " << nbMegots << "   Nb Cabarets envoyes: " << ((int) (nbMegots / capCabaret)) << "\nTemps: " << temps << "\n";

	salleFond.travaille();
}

//**************************************************************************************************

class Scellement {
	private :
		int capCabaret;	// nombre de megots ou d'anodes par cabaret
		double tauxA;			// taux de scellement des anodes
		double nbMegots;    	// nombre de megots
		double nbAnodes;    	// nombre d'anodes
		long temps;
		Entrepot & salleEnt;
		int dureePas;
	public :
		Scellement(int dureePas, double tauxA, Entrepot & salleEntx);
		void travaille(void);
		void donneAnodes(int nbAnodes);
		int recoitMegots(int nbMegots);
		void setDureePas(int dureePas);
};

Scellement::Scellement(int dureePas, double tauxA, Entrepot & salleEntx):salleEnt(salleEntx) {

	this -> tauxA = tauxA;
	this -> dureePas = dureePas;

	capCabaret = 6;
	dureePas = 15;
	nbMegots = 100;
	nbAnodes = 100;
	temps = 0;
}

void Scellement::setDureePas(int dureePas) {
	this -> dureePas = dureePas;
}

void Scellement::travaille(void) {

	long quartTravaille;

	temps += dureePas;

	quartTravaille = (long) temps/60;

	nbMegots += salleEnt.donneMegots();

	if ((quartTravaille % 8) < 7)
	{
		if (nbMegots > tauxA/(60/dureePas))
		{
			nbAnodes += tauxA/(60/dureePas); // reparation des anodes
			nbMegots -= tauxA/(60/dureePas);
		}
		else if (nbMegots > 0)
		{
			nbAnodes += nbMegots;
				// Les employés sont en break pour nbMegots * 60/tauxA minutes.
			nbMegots = 0;
		}
		else
		{
			// Les employés sont en break pour dureePas minutes.
		}

		salleEnt.recoitAnodes(((int) (nbAnodes/capCabaret)) * capCabaret);
		nbAnodes -= ((int) (nbAnodes/capCabaret)) * capCabaret;

		cout << "Scellement... Anodes: " << nbAnodes << " Megots: " << nbMegots << endl << endl;

	}
	else
		cout << endl;


}

//****************************************************************************

void main(void)
{
	int dureePas;
	char option = 'A';

	switch(option)
	{
		case ('A'):
		case ('a'):
			dureePas = 15;
			break;
		case ('B'):
		case ('b'):
			dureePas = 10;
			break;
		case ('C'):
		case ('c'):
			dureePas = 5;
			break;
		default :
			cout << "Entrez un caractere valide! Les options se limite a A, B ou C";
	}

	Entrepot salleEnt(dureePas, 20, 10, 100, 100, 100);
	Fonderie salleFond(dureePas);
	Electrolyse elec(dureePas, 25, salleEnt, salleFond);
	Scellement salleSc(dureePas, 67, salleEnt);

//	salleEnt.setDureePas(elec.getDureePas());
//	salleSc.setDureePas(elec.getDureePas());
//	salleFond.setDureePas(elec.getDureePas());

	for (int i = 0; i < 1000; i++)
	{
		clrscr();
		elec.travaille();
		salleEnt.travaille();
		salleSc.travaille();
		//delay(200);
		getch();
	}
	getch();
}