#include "Distributeur.h"

#include <iostream>
#include <fstream>
#include <string>
#include <stdio.h>
using namespace std;

//////////////////////////////////////////////////////////////////////
//							Constructeur							//
//////////////////////////////////////////////////////////////////////
Distributeur::Distributeur()
{
}

//////////////////////////////////////////////////////////////////////
//							Accesseurs								//
//////////////////////////////////////////////////////////////////////
Ingredient* Distributeur::Get_Ingredient(string Nom_Ingredient)
{
	int I,Indice;

	for (I=0;I<14;I++)
	{
		if (this->Tab_Ingredient[I]->Get_Nom() == Nom_Ingredient)
			Indice=I;
	}
	return Tab_Ingredient[Indice];
}


Boisson* Distributeur::Get_Boisson(string Nom_Boisson)
{
	int I,Indice;

	I=Indice=0;
	for (I=0;I<10;I++)
	{
		if (this->Tab_Boisson[I]->Get_Nom() == Nom_Boisson)
			Indice=I;
	}
	return Tab_Boisson[Indice];
}


Lot_Piece* Distributeur::Get_Lot_Piece(string Val_Piece)
{
	int I,Indice;

	for (I=0;I<7;I++)
	{
		if (this->Tab_Lot_Piece[I]->Get_Valeur() == atoi(Val_Piece.c_str()))
			Indice=I;
	}
	return Tab_Lot_Piece[Indice];
}

//////////////////////////////////////////////////////////////////////
//						Fonctions principales						//
//////////////////////////////////////////////////////////////////////
int Distributeur::Initialisation()
{
	//variables
	int I_Resultat=0; //Entier pour retour d'erreur	
	FILE * Fic_Ing = NULL; //fichiers
	FILE * Fic_Boisson = NULL; //fichiers
	FILE * Fic_Lot_Piece = NULL; //fichiers
	string Name_Fic_Ing; //Noms de fichiers
	string Name_Fic_Boisson; //Noms de fichiers
	string Name_Fic_Lot_Piece; //Noms de fichiers
	char Nom_Fichier[TAILLEMAX]; //chaine contenant le nom de fichier + chemin
	char ligne[TAILLEMAX]; //Chaine contenant la ligne lue
	string Temp; //string temporaire
	Ingredient* Ing_Temp; //ingredient temporaire pr fill tab
	Boisson* Boisson_Temp; //boisson temporaire pr fill tab
	Lot_Piece* Lot_Temp; //lot piece temporaire pr fill tab
	int Compteur=0;

	//Init des noms de fichier
	Name_Fic_Ing="Ingredient.txt";
	Name_Fic_Boisson="Boisson.txt";
	Name_Fic_Lot_Piece="Stock_Piece.txt";

	//Chargement des ingrédients
	strcpy(Nom_Fichier,"APP_PATH");
	strcat(Nom_Fichier,Name_Fic_Ing.c_str());
	Fic_Ing=fopen(Nom_Fichier, "rt");
	if(Fic_Ing==NULL)
	{
		I_Resultat=1;		
	}
	else
	{
		I_Resultat=0;
		while((fgets(ligne, TAILLEMAX, Fic_Ing))&&(Compteur<=14))
		{
			Temp=ligne;
			Ing_Temp=this->Construire_Ing(Temp);
			this->Tab_Ingredient[Compteur]=Ing_Temp;
			Compteur=Compteur+1;
        }
		fclose(Fic_Ing);
	}
	
	//Chargement des boissons
	Compteur=0;
	strcpy(Nom_Fichier,"APP_PATH");
	strcat(Nom_Fichier,Name_Fic_Boisson.c_str());
	Fic_Boisson=fopen(Nom_Fichier, "rt");
	if(Fic_Boisson==NULL)
	{
		I_Resultat=2;		
	}
	else
	{
		I_Resultat=0;
		while((fgets(ligne, TAILLEMAX, Fic_Boisson))&&(Compteur<=10))
		{
			Temp=ligne;
			Boisson_Temp=this->Construire_Boisson(Temp);			
			this->Tab_Boisson[Compteur]=Boisson_Temp;
			Compteur=Compteur+1;
        }
		fclose(Fic_Boisson);
	}

	//Chargement des lot piece
	Compteur=0;
	strcpy(Nom_Fichier,"APP_PATH");
	strcat(Nom_Fichier,Name_Fic_Lot_Piece.c_str());
	Fic_Lot_Piece=fopen(Nom_Fichier, "rt");
	if(Fic_Lot_Piece==NULL)
	{
		I_Resultat=3;		
	}
	else
	{
		I_Resultat=0;
		while((fgets(ligne, TAILLEMAX, Fic_Lot_Piece))&&(Compteur<=6))
		{
			Temp=ligne;
			Lot_Temp=this->Construire_Lot_Piece(Temp);
			this->Tab_Lot_Piece[Compteur]=Lot_Temp;
			Compteur=Compteur+1;
        }
		fclose(Fic_Lot_Piece);
	}

	return I_Resultat;
}

void Distributeur::Afficher(int aff)
// fonction Afficher
// paramètres : 0 pour les pièces, 1 pour les boissons, 2 pour les stocks, 3 pour le type d'action (quitter, boire, gérer)
{
	int i;

	switch(aff)
	{
	case 0:
		// affichage des différentes pièces
		system("cls");
		cout<<"Voici la liste des pièces disponinbles"<<endl;
		cout<<"1. pièce de  2 EUR"<<endl;
		cout<<"2. pièce de  1 EUR"<<endl;
		cout<<"3. pièce de 50 cts"<<endl;
		cout<<"4. pièce de 20 cts"<<endl;
		cout<<"5. pièce de 10 cts"<<endl;
		cout<<"6. pièce de  5 cts"<<endl;
		cout<<"\n Ce menu se quittera quand assez de monnaie sera rentrée"<<endl;

	case 1:
		// liste des boissons
		system("cls");
		for(i=0; i<11; i++)
		{
			cout<<i+1<<Tab_Boisson[i]->Get_Nom()<<" : "<<Tab_Boisson[i]->Get_Prix()<<" centimes"<<endl;
			i++;
		}

	case 2:
		// liste des stocks
		system("cls");
		for(i=0; i<14; i++)
		{
			cout<<"Stock de "<<Tab_Ingredient[i]->Get_Nom()<<" : "<<Tab_Ingredient[i]->Get_Quantite_Actuelle()<<endl;
			i++;
		}

	case 3:
		system("cls");

		cout<<"1. Boire"<<endl;
		cout<<"2. Gérer"<<endl;
		cout<<"3. Quitter"<<endl;
	}
}

Boisson* Distributeur::Choisir_Boisson()
{
	Boisson* Boisson_Choisie;
	int Indice_Boisson;
	string Nom_Boisson;

	this->Afficher(1);
	cin>>Indice_Boisson;
	Nom_Boisson = this->Tab_Boisson[Indice_Boisson - 1]->Get_Nom();
	Boisson_Choisie = this->Get_Boisson(Nom_Boisson);
	return Boisson_Choisie;
}

void Distributeur::Payer(int Prix)
{
	int Val_Piece;
	int Val_Totale = 0;
	
	do
	{
		// afficher la liste des pièces
		Afficher(0);
		//choix de la pièce à insérer dans la fente
		do 
		{
			cout<<"Choisissez votre pièce"<<endl;
			cin>>Val_Piece;
		}while ((Val_Piece <= 0)||(Val_Piece >= 7));//pièce entre 5 cts et 2 EUR
		// ajouter la valeur de la pièce au total payé
		if (Val_Piece == 1)
			Val_Piece = 200;
		if (Val_Piece == 2)
			Val_Piece = 100;
		if (Val_Piece = 3)
			Val_Piece = 50;
		if (Val_Piece == 4)
			Val_Piece = 20;
		if (Val_Piece == 5)
			Val_Piece = 10;
		if (Val_Piece == 6)
			Val_Piece = 5;
		Val_Totale = Val_Totale + Val_Piece;
		cout<<"Vous avez mis : "<<Val_Piece<<" cts"<<endl;
	}while (Val_Totale < Prix);
	Rendre_Monnaie(Val_Totale - Prix);
}

void Distributeur::Rendre_Monnaie(int diff)
{
	// rendre pièce de 2 EUR
	while ((diff >= 200)&&(Tab_Lot_Piece[5]->Get_Quantite_Piece() > 0))
	{
		// retirer la pièce du stock
		Tab_Lot_Piece[5]->Enlever();
		// soustraire à la diférence
		diff=diff-200;
	}
	// rendre pièce de 1 EUR
	// la fonction while permet de boucler tant qu'on peut fournir de cette pièce et palie le manque de la pièce précédente
	while ((diff >= 100)&&(Tab_Lot_Piece[4]->Get_Quantite_Piece() >0))
	{
		// retirer la pièce du stock
		Tab_Lot_Piece[4]->Enlever();
		// soustraire à la diférence
		diff=diff-100;
	}
	while ((diff >= 50)&&(Tab_Lot_Piece[3]->Get_Quantite_Piece() >0))
	{
		// retirer la pièce du stock
		Tab_Lot_Piece[3]->Enlever();
		// soustraire à la diférence
		diff=diff-50;
	}
	while ((diff >= 20)&&(Tab_Lot_Piece[2]->Get_Quantite_Piece() >0))
	{
		// retirer la pièce du stock
		Tab_Lot_Piece[2]->Enlever();
		// soustraire à la diférence
		diff=diff-20;
	}
	while ((diff >= 10)&&(Tab_Lot_Piece[1]->Get_Quantite_Piece() >0))
	{
		// retirer la pièce du stock
		Tab_Lot_Piece[1]->Enlever();
		// soustraire à la diférence
		diff=diff-10;
	}
	while ((diff >= 5)&&(Tab_Lot_Piece[0]->Get_Quantite_Piece() >0))
	{
		// retirer la pièce du stock
		Tab_Lot_Piece[0]->Enlever();
		// soustraire à la diférence
		diff=diff-5;
	}
}

void Distributeur::Check_Stock()
{
	int I;
	
	// gestion des stocks d'ingredients
	for (I=0; I<14; I++)
	{	
		if (this->Tab_Ingredient[I]->Get_Quantite_Actuelle() < this->Tab_Ingredient[I]->Get_Seuil_Alerte_Min())
			this->Alerter(true, I);
	}

	// gestion des stocks de pieces
	for (I=0; I<7; I++)
	{
		// cas : il n'y a plus de monnaie
		if (this->Tab_Lot_Piece[I]->Get_Quantite_Piece() < this->Tab_Lot_Piece[I]->Get_Seuil_Alerte_Min())
			this->Alerter(false, I);
		// cas : il y a trop de pieces
		if (this->Tab_Lot_Piece[I]->Get_Quantite_Piece() > this->Tab_Lot_Piece[I]->Get_Seuil_Alerte_Max())
			this->Alerter(false, I+10);
	}
}

void Distributeur::Remplir_Stock(bool Ingr_Piece, int Indice)
// fonction Remplir stock
// paramètres : true : ingrédient, false : pièce
//				indice dans le tableau d'ingrédients ou de pièces
{
	if (Ingr_Piece == true) //c'est un stock d'ingrédient
	{
		this->Tab_Ingredient[Indice]->Set_Quantite_Actuelle(this->Tab_Ingredient[Indice]->Get_Quantite_Max());
		//écrire dans le fichier texte
	}
	else //c'est un lot de pièces
	{
		this->Tab_Lot_Piece[Indice]->Set_Quantite_Piece(200);
		//écrire dans le fichier texte
	}
}

void Distributeur::Alerter(bool Ingr_Piece, int Indice)
// fonction Alerter
// paramètres : true : ingrédient, false : pièce
//				indice dans le tableau d'ingrédients ou de pièces
{
	if (Ingr_Piece == true) //c'est un ingrédient
	{
		switch(Indice) // correspond à l'indice dans le tableau d'ingrédients
		{
		case 0:
			cout<<"Le seuil mini de café a été atteint"<<endl;
		case 1:
			cout<<"Le seuil mini de thé vert a été atteint"<<endl;
		case 2:
			cout<<"Le seuil mini de thé noir a été atteint"<<endl;
		case 3:
			cout<<"Le seuil mini de thé citron a été atteint"<<endl;
		case 4:
			cout<<"Le seuil mini de cacao a été atteint"<<endl;
		case 5:
			cout<<"Le seuil mini de sucre a été atteint"<<endl;
		case 6:
			cout<<"Le seuil mini de lait a été atteint"<<endl;
		case 7:
			cout<<"Le seuil mini de potage tomate a été atteint"<<endl;
		case 8:
			cout<<"Le seuil mini de potage céleri a été atteint"<<endl;
		case 9:
			cout<<"Le seuil mini de potage poulet a été atteint"<<endl;
		case 10:
			cout<<"Le seuil mini d'eau a été atteint"<<endl;
		case 11:
			cout<<"Le seuil mini de batonnets a été atteint"<<endl;
		case 12:
			cout<<"Le seuil mini de gobelets a été atteint"<<endl;
		case 13:
			cout<<"Le seuil mini de sel a été atteint"<<endl;
		}
	}
	else //c'est un lot de pièces
	{
		switch(Indice)
		{
		// Indice dans le tableau de lots de pièces
		case 0:
			cout<<"Le seuil mini de pièces de 5 centimes a été atteint"<<endl;
		case 1:
			cout<<"Le seuil mini de pièces de 10 centimes a été atteint"<<endl;
		case 2:
			cout<<"Le seuil mini de pièces de 20 centimes a été atteint"<<endl;
		case 3:
			cout<<"Le seuil mini de pièces de 50 centimes a été atteint"<<endl;
		case 4:
			cout<<"Le seuil mini de pièces de 1 euro a été atteint"<<endl;
		case 5:
			cout<<"Le seuil mini de pièces de 2 euros a été atteint"<<endl;
		// Indice dans le tableau de lots de pièces +10
		case 10:
			cout<<"Le seuil maxi de pièces de 5 centimes a été atteint"<<endl;
		case 11:
			cout<<"Le seuil maxi de pièces de 10 centimes a été atteint"<<endl;
		case 12:
			cout<<"Le seuil maxi de pièces de 20 centimes a été atteint"<<endl;
		case 13:
			cout<<"Le seuil maxi de pièces de 50 centimes a été atteint"<<endl;
		case 14:
			cout<<"Le seuil maxi de pièces de 1 euro a été atteint"<<endl;
		case 15:
			cout<<"Le seuil maxi de pièces de 2 euros a été atteint"<<endl;
		}
	}
}

//////////////////////////////////////////////////////////////////////
//					Fonctions de construction						//
//////////////////////////////////////////////////////////////////////
Lot_Piece* Distributeur::Construire_Lot_Piece(string Chaine_Init)
{
	int Valeur;
	int Quantite_Piece;
	int Position, Nb_Champ, Last_Position;
	string Temp1,Temp2;

	//Découper la chaine de caracteres pr extraire les infos
	//champ1 = valeur, champ2 = qte pièce
	Position=0;
	Last_Position=0;
	Nb_Champ=0;

	Temp1=Chaine_Init.substr(Position,1);
	while(Position<Chaine_Init.length())
	{
		Position=Position+1;
		Temp1=Chaine_Init.substr(Position,1);
		if(Temp1==";")
		{
			Nb_Champ=Nb_Champ+1;
			switch(Nb_Champ)
			{
			case 1:
				{
					//Valeur
					Temp2=Chaine_Init.substr(Last_Position,Position-Last_Position);
					Valeur=atoi(Temp2.c_str());
				}
			case 2:
				{
					//qte pièce
					Temp2=Chaine_Init.substr(Last_Position,Position-Last_Position);
					Quantite_Piece=atoi(Temp2.c_str());
				}
			Last_Position=Position+1;
			}
		}
	}

	//Création du lot de pièces
	Lot_Piece* Lot_Retourne=new Lot_Piece(Valeur,Quantite_Piece);

	return Lot_Retourne;
}

Ingredient* Distributeur::Construire_Ing(string Chaine_Init)
{
	string Nom;
	int Quantite_Max;
	int Quantite_Actuelle;
	int Nb_Dose;
	int Qte_Dose;
	int Position, Nb_Champ, Last_Position;
	string Temp1,Temp2;

	//Découper la chaine de caracteres pr extraire les infos
	//champ1 = nom, champ2 = qte actuelle, champ3 = nb dose, champ4 = Qte max
	Position=0;
	Last_Position=0;
	Nb_Champ=0;
	
	Temp1=Chaine_Init.substr(Position,1);
	while(Position<Chaine_Init.length())
	{
		Position=Position+1;
		Temp1=Chaine_Init.substr(Position,1);
		if(Temp1==";")
		{
			Nb_Champ=Nb_Champ+1;
			switch(Nb_Champ)
			{
			case 1:
				{
					//Nom
					Nom=Chaine_Init.substr(Last_Position,Position-Last_Position);
					Last_Position=Position+1;
				}
			case 2:
				{
					//qte actuelle
					Temp2=Chaine_Init.substr(Last_Position,Position-Last_Position);
					Quantite_Actuelle=atoi(Temp2.c_str());
					Last_Position=Position+1;
				}
			case 3:
				{
					//Nb doses
					Temp2=Chaine_Init.substr(Last_Position,Position-Last_Position);
					Nb_Dose=atoi(Temp2.c_str());
					Last_Position=Position+1;
				}
			case 4:
				{
					//Qte max
					Temp2=Chaine_Init.substr(Last_Position,Position-Last_Position);
					Quantite_Max=atoi(Temp2.c_str());
					Last_Position=Position+1;
				}
			}
		}
	}
	//en fonction de l'ingrédient on a des doses différentes
	if(Nom=="eau")
	{
		Qte_Dose=6;
	}
	else
	{
		if((Nom=="batonnet")||(Nom=="gobelet"))
		{
			Qte_Dose=1;
		}
		else
		{
			Qte_Dose=12;
		}
	}
	
	//Création de l'ingrédient
	Ingredient* Ing_Retourne=new Ingredient(Quantite_Max,Nb_Dose,Qte_Dose,Quantite_Actuelle);
	Ing_Retourne->Set_Nom(Nom);


	return Ing_Retourne;
}

Boisson* Distributeur::Construire_Boisson(string Chaine_Init)
{
	int Temperature;
	int Prix;
	int Position, Nb_Champ, Last_Position;
	string Temp1,Temp2,Type,Nom;

	//Découper la chaine de caracteres pr extraire les infos
	//champ1 = type, champ2 = nom, champ3 = prix, champ4 = temperature
	Position=0;
	Last_Position=0;
	Nb_Champ=0;
	
	Temp1=Chaine_Init.substr(Position,1);
	while(Position<Chaine_Init.length())
	{
		Position=Position+1;
		Temp1=Chaine_Init.substr(Position,1);
		if(Temp1==";")
		{
			Nb_Champ=Nb_Champ+1;
			switch(Nb_Champ)
			{
			case 1:
				{
					//type
					Type=Chaine_Init.substr(Last_Position,Position-Last_Position);
					Last_Position=Position+1;
				}
			case 2:
				{
					//Nom
					Nom=Chaine_Init.substr(Last_Position,Position-Last_Position);
					Last_Position=Position+1;
				}
			case 3:
				{
					//Prix
					Temp2=Chaine_Init.substr(Last_Position,Position-Last_Position);
					Prix=atoi(Temp2.c_str());
					Last_Position=Position+1;
				}
			case 4:
				{
					//Temperature
					Temp2=Chaine_Init.substr(Last_Position,Position-Last_Position);
					Temperature=atoi(Temp2.c_str());
					Last_Position=Position+1;
				}
			}
		}
	}
	//Création de la boisson
	if(Type=="cafe")
	{
		Cafe* Boiss=new Cafe(Prix,Temperature);
		Boiss->Set_Nom(Nom);
		//Init tab ing
		Boiss->Construire_Recette();
		return Boiss;
	}
	if(Type=="chocolat")
	{
		Chocolat* Boiss=new Chocolat(Prix,Temperature);
		Boiss->Set_Nom(Nom);
		//Init tab ing
		Boiss->Construire_Recette();
		return Boiss;
	}
	if(Type=="the")
	{
		The* Boiss=new The(Prix,Temperature);
		Boiss->Set_Nom(Nom);
		//Init tab ing
		Boiss->Construire_Recette();
		return Boiss;
	}
	if(Type=="potage")
	{
		Potage* Boiss=new Potage(Prix,Temperature);
		Boiss->Set_Nom(Nom);
		//Init tab ing
		Boiss->Construire_Recette();
		return Boiss;
	}
	else
	{
		Boisson* Boiss=new Boisson();
		return Boiss;
	}
}