#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#include<iostream.h>
#include<iomanip.h>
class rangee{
private:
	int typ;
	int cptr;
	int temps_refroid;
public:
	rangee(int = -1,int = 0, int = -2);
	void set_typ(int);
	void set_cptr(int);
	void set_temps_refroid(int);
	int  get_typ(void);
	int  get_cptr(void);
	int  get_temps_refroid(void);
};
class type_entrepot {
private:
	int rangee_voulu_client;
	rangee * tab;
	int qte_cab_megot_stock;
	int qte_cab_anode_stock;

public:
	type_entrepot(int qtavoulu,int nb_rangee);
	void  echanger_cab_electro(int);
  //	void  echanger_cab_scell(int);
	int   get_qte_cab_anode_stock(void) const;
	void  afficher_stock();
	type_entrepot (const type_entrepot &);
	void remplir_de_megots(int &,int);//Fonctions utilitaires qui se rapporte
	void vider_de_megots(int &,int);  //au tableau de rangees de l'entrepot.
	void remplir_de_anodes(int &,int);//n'affecte pas les variables privates
	void vider_de_anodes(int &,int);  //qte_cab_stock!!!
	int  echange_poss_electro_entrpt(const int);  //Fonctions utiliitaires qui confirme
	//	int  echange_poss_scell_entrept();   //si un echange est possible ou non.
	void decremente(void);
};
class type_electrolyse {
private:
	type_entrepot & entrepot;
	const double taux_prod_megot;//20.7 megots/heure
	double taux_prod_actuel;
	double taux_tampon_megot;//megots non-evacues apres echange
	int nbre_cab_echanges;
public:
	type_electrolyse(type_entrepot & cible);
	int travaille(void);
	void afficher(void);
};
//****************************************************************************
// DEFINITIONS DES FONCTIONS DE CLASSE RANGEE
// constructeur de la classe rangee
rangee::rangee(int st,int cp, int tp)
{
	set_typ(st);
	set_cptr(cp);
	set_temps_refroid(tp);
}
void rangee::set_typ(int s)
{
	typ=s;
}
void rangee::set_cptr(int c)
{
	cptr=c;
}
void rangee::set_temps_refroid(int t)
{
	temps_refroid=t;
}
int  rangee::get_typ(void){return typ;}
int  rangee::get_cptr(void){return cptr;}
int  rangee::get_temps_refroid(void){return temps_refroid;}
//****************************************************************************
// DEFINITIONS DES FONCTIONS DE CLASSE TYPE ENTREPOT
// constructeur de la classe type entrepot
type_entrepot::type_entrepot(int qtavoulu,int nb_rangee)
	{
		qte_cab_anode_stock=(qtavoulu%6==0? qtavoulu : 30);
		qte_cab_megot_stock=0;
		rangee_voulu_client=(nb_rangee*6 > qte_cab_anode_stock? nb_rangee :
		(qte_cab_anode_stock/6 + 2));
		tab= new rangee[rangee_voulu_client];
		for (int j=0;j < (qte_cab_anode_stock/6);j++)
		{
			tab[j].set_typ(1);
			tab[j].set_cptr(6);
			tab[j].set_temps_refroid(-1);
		}
		for (j=(qte_cab_anode_stock/6);j< rangee_voulu_client;j++)
		{
			tab[j].set_typ(0);
			tab[j].set_cptr(0);
			tab[j].set_temps_refroid(-1);
		}
	cout<<"HORLOGE(h):0"<<endl;
	afficher_stock();
	cout<<endl<<endl<<endl;
	getch();
	}
type_entrepot::type_entrepot (const type_entrepot & ancien)
{
	qte_cab_anode_stock=ancien.qte_cab_anode_stock;
	qte_cab_megot_stock=ancien.qte_cab_megot_stock;
}
void  type_entrepot::echanger_cab_electro(int qte)
{
	qte_cab_megot_stock += qte;
	qte_cab_anode_stock -= qte;
}

/*void type_entrepot::echanger_cab_scell(long qte)
{
		 if( echange_poss_scell_entrpt(qte))
		 {
		qte_cab_megot_stock -= qte;
		qte_cab_anode_stock += qte;
		return 1;
		 }
		 else return 0;

}  */
void type_entrepot::afficher_stock()
{
	cout << "# cabarets de megots en stock ds l'entrepot:"<< qte_cab_megot_stock
			<<endl << "# cabarets d' anodes en stock ds l'entrepot:"<< qte_cab_anode_stock
			<<endl << "contenu et suivis des rangees ds l'entrepot:"<< endl;
	for(int j=0;j<rangee_voulu_client;j++)
		{
		cout << setw(5)<<tab[j].get_typ();
		}
	cout << endl;
	for(j=0;j<rangee_voulu_client;j++)
		{
		cout << setw(5)<<tab[j].get_cptr();
		}
	cout << endl;
	for(j=0;j<rangee_voulu_client;j++)
		{
		cout << setw(5)<<tab[j].get_temps_refroid();
		}
	cout << endl;
}
int type_entrepot::get_qte_cab_anode_stock(void) const {
	return qte_cab_anode_stock;}
void type_entrepot::remplir_de_megots(int & quantite,int k)
{
	int tampon;
	if((tab[k].get_cptr() + quantite)>=6)
	{
		tampon=(tab[k].get_cptr() + quantite) - 6;
		tab[k].set_cptr(6);
		tab[k].set_temps_refroid(4);
		tab[k].set_typ(2);
		quantite = tampon;
	}
	else tab[k].set_cptr(tab[k].get_cptr() + quantite);
			tab[k].set_typ(2);
			quantite = 0;
}
void type_entrepot::remplir_de_anodes(int & quantite,int k)
{
	int tampon;
	if((tab[k].get_cptr() + quantite)>=6)
	{
		tampon=(tab[k].get_cptr() + quantite) - 6;
		tab[k].set_cptr(6);
		tab[k].set_typ(1);
		quantite = tampon;
	}
	else tab[k].set_cptr(tab[k].get_cptr() + quantite);
			tab[k].set_typ(1);
			quantite = 0;
}
void type_entrepot::vider_de_megots(int & quantite,int k)
{
	int tampon;
	if((tab[k].get_cptr() - quantite)<=0)
	{
		tampon=quantite - tab[k].get_cptr();
		tab[k].set_cptr(0);
		tab[k].set_typ(0);
		tab[k].set_temps_refroid(-1);
		quantite=tampon;
	}
	else
	{
		tab[k].set_cptr((tab[k].get_cptr() - quantite));
		quantite = 0;
	}
}
void type_entrepot::vider_de_anodes(int & quantite,int k)
{
	int tampon;
	if((tab[k].get_cptr() - quantite)<=0)
	{
		tampon=quantite - tab[k].get_cptr();
		tab[k].set_cptr(0);
		tab[k].set_typ(0);
		tab[k].set_temps_refroid(-1);
		quantite=tampon;
	}
	else
	{
		tab[k].set_cptr((tab[k].get_cptr() - quantite));
		quantite = 0;
	}
}
int  type_entrepot::echange_poss_electro_entrpt(const int qte_cab)
{
	int temp_cab=qte_cab;
	for(int j=0;j<rangee_voulu_client;j++)
	{
		if( ((tab[j]).get_typ()==2) && ((tab[j]).get_cptr() != 6))
			remplir_de_megots(temp_cab,j);
		if (temp_cab==0) break;
	}
	if(temp_cab != 0)
	{
		for(int j=0;j<rangee_voulu_client;j++)
		{
			if( (tab[j].get_typ()==0) )
			remplir_de_megots(temp_cab,j);
		if (temp_cab ==0) break;
		}
	}
	if(temp_cab == 0)
	{
		temp_cab=qte_cab;
		for(int j=0;j<rangee_voulu_client;j++)
		{
		if( (tab[j].get_typ()==1) && (tab[j].get_cptr() != 0))
			vider_de_anodes(temp_cab,j);
		if (temp_cab==0) break;
		}
		if(temp_cab == 0)
		return 1;
		else return 0;
	}
	else return 0;
}
void type_entrepot::decremente(void)
{
	for (int j=0;j<rangee_voulu_client;j++)
	{
		if(tab[j].get_temps_refroid() > 0)
		{
			int temp= tab[j].get_temps_refroid() -1;
			tab[j].set_temps_refroid(temp);
		}
	}
}
//int  type_entrepot::echange_poss_scell_entrept();
//*****************************************************************************
// DEFINITIONS DES FONCTIONS DE CLASSE TYPE ELECTROLYSE
// constructeur de la classe type electrolyse
type_electrolyse::type_electrolyse(type_entrepot & cible)
	:entrepot(cible),taux_prod_megot(20.7){
	taux_tampon_megot = 0;
	taux_prod_actuel = 0;
	nbre_cab_echanges = 0;
	}
int type_electrolyse::travaille()
{
	taux_prod_actuel=taux_prod_megot + taux_tampon_megot;
	int nbre_cabarets_produit =taux_prod_actuel/6;

	if(entrepot.get_qte_cab_anode_stock())
	{
		if( entrepot.get_qte_cab_anode_stock() >= ( nbre_cabarets_produit))
		{
			nbre_cab_echanges = nbre_cabarets_produit;
			if(entrepot.echange_poss_electro_entrpt(nbre_cab_echanges))
			{
				entrepot.echanger_cab_electro(nbre_cab_echanges);
				taux_tampon_megot= taux_prod_actuel - (6*nbre_cab_echanges);
			}
		}
		else
		{
			nbre_cab_echanges = entrepot.get_qte_cab_anode_stock();
			if(entrepot.echange_poss_electro_entrpt(nbre_cab_echanges))
			{
				entrepot.echanger_cab_electro(nbre_cab_echanges);
				taux_tampon_megot= taux_prod_actuel - (6*nbre_cab_echanges);
			}
		}
	afficher();
	entrepot.decremente();
	return 1;
	}
	else
	{ afficher();
		entrepot.decremente();
		return 0;
	}
}

void type_electrolyse::afficher(void)
{
	entrepot.afficher_stock();
	cout << " taux de prod. au coup d'horloge : " << taux_prod_actuel
	<<endl << "nbre de cabarets echanges : "<<nbre_cab_echanges
	<<endl << "taux tampon de megots : " << taux_tampon_megot
	<<endl<<endl<<endl<<endl;
}
// PROGRAMME PRINCIPAL
int main(void){
	clrscr();
	type_entrepot E(18,5 );
	type_electrolyse S(E);
	for (int horloge = 1; horloge < 10 ; horloge++)
		{
		cout<<"HORLOGE(h):"<<horloge<<endl;
		S.travaille();
			getch();

		}
return EXIT_SUCCESS;
}