/*Examen blanc - Combat de Robots Carlo Piussi - le 17 décembre 2017*/
#include <iostream>
#include <iomanip>
#include <list>
#include <vector>
#include <algorithm>
#include <string>
#include <locale>
using namespace std;

class boule {
private:
	int numero;
	char couleur;
public:
	void saisie();
	void affiche();
	bool operator==(boule);
	int getVal(){
		return numero;
	};
	char getCouleur(){
		return couleur;
	}
	boule(){
		cout<<"Constructeur boule par défaut"<<endl;
	
	}

	~boule(){
		cout<<"Destructeur boule"<<endl;
	}
};

void boule::saisie(){
		cout<<"Couleur\n=? "<<endl;
		cin>>couleur;
		cout<<"\nValeur\n=? "<<endl;
		cin>>numero;
	};

void boule::affiche(){
		cout<<couleur<<endl;
		cout<<numero<<endl;
		cout<<" "<<endl;
	};

//Saisie Robot1 list
void saisieRobot1List(list<boule>&robot1){
	int N=0;
	cout<<"Combien de boules voulez-vous que Robot1 saisisse ?"<<endl;
	cin>>N;
	for (int i = 0; i < N; i++)
	{
		boule tmp;
		tmp.saisie();
		robot1.insert(robot1.begin(),tmp);
	}
}
//Saisie Robot2 vector
void saisieRobot2Vector(vector<boule>&robot2){
	int N=0;
	cout<<"Combien de boules voulez-vous que Robot2 saisisse ?"<<endl;
	cin>>N;
	for (int i = 0; i < N; i++)
	{
		boule tmp;
		tmp.saisie();
		robot2.insert(robot2.begin(),tmp);
	}
}
//template saisie
template<class X, class Y> void saisieRobot(X &robot, Y S) {
	int N=0;
	robot.clear();//si l'on veut recommencer à saisir le container de zéro à chaque appel de la fonction
	cout<<S<<endl;
	cin>>N;
	for (int i = 0; i < N; i++)
	{
		boule tmp;//à mettre ici seulement si on utilise l'autro-incrément, sinon il peut aller en amont du for
		cout << endl;
		tmp.saisie();
		robot.insert(robot.begin(),tmp);
	}
}
//Affiche Robot1 list
void afficheRobot1List(list<boule>robot1){
	cout<<"Robot1 - List"<<endl;
	list<boule>::iterator it;
	for (it=robot1.begin(); it!=robot1.end(); it++){
		it->affiche();
	}
}
//Affiche Robot2 vector
void afficheRobot2Vector(vector<boule>robot2){
	cout<<"Robot2 - vector"<<endl;
	vector<boule>::iterator it;
	for (it=robot2.begin(); it!=robot2.end(); it++){
		it->affiche();
	}
}
//template affiche
template <class T, class U, class V> void afficheRobot(T robotLV, U itlv, V S){
	cout<< S <<endl;
	
	for (itlv=robotLV.begin(); itlv!=robotLV.end(); itlv++){
		itlv->affiche();
	}
}
//Qui est le gagnant
/*void somme(list<boule> robot1,vector <boule> robot2,int &sommeRobot1,int &sommeRobot2){
	list<boule>::iterator itl;
	vector<boule>::iterator itv;


	for (itl = robot1.begin(); itl !=robot1.end(); itl++)
	{
		if (itl->getCouleur()=='R')
		{
			sommeRobot1=sommeRobot1 + (*itl).getVal();
		}
		else
		{
			sommeRobot1=sommeRobot1 - (*itl).getVal();
		}
		
	}


	for (itv = robot2.begin(); itv !=robot2.end(); itv++)
	{
		if (itv->getCouleur()=='B')
		{
			sommeRobot2=sommeRobot2 + itv->getVal();
		}
		else
		{
			sommeRobot2=sommeRobot2 - itv->getVal();
		}
		
	}
	cout<<"Somme Robot1 - list\t=\t"<<sommeRobot1<<endl;
	cout<<"Somme Robot2 - vector\t=\t"<<sommeRobot2<<endl;
}
*/

bool boule::operator==(boule Robot1){
	if (couleur==Robot1.getCouleur())
	{
		return true;
	} else
	{
		return 0;
	}
}
/*
template<class T, class U, class V> int somme(T robot, U it, V RB) {
//	U it;
	int som = 0;
//	V RB;
	for (it = robot.begin(); it!=robot.end(); it++){
		if (it->getCouleur()==RB)
		{
			som=som+it->getVal();
		}
		else{
			som=som-it->getVal();
		}
	}
	return som;
}
*/
template<class T, class U, class V> int somme(T robot, U iter ,V RB) {
	U it;
	int som = 0;
//	V RB;
	for (it = robot.begin(); it!=robot.end(); it++){
		if ((*it).getCouleur()==RB)
		{
			som=som+it->getVal();
		}
		else{
			som=som-it->getVal();
		}
	}
	return som;
}

//Case 4 - Mettre de l'ordre
//template<class T, class U, class V, class W> void ordre(T &Robot1L, V &Robot2V){
//Ne pas faire de template, ce n'est pas utile
void ordre(list<boule> &Robot1L, vector <boule> &Robot2V, list<boule>::iterator itl, vector<boule>::iterator itv){	
	//U itl;
	//W itv;
	for (itl = Robot1L.begin(); itl!=Robot1L.end(); itl++){
		if (itl->getCouleur() == 'N') {
		//Au lieu de ce code, on pourrait écrire : it=find(tab.begin(), tab.end(), 'n');
			Robot1L.erase(itl);     
			itl=Robot1L.begin();
		}
		if (itl->getCouleur() == 'B') {
			Robot2V.insert(Robot2V.begin(), *itl);
			Robot1L.erase(itl);
			itl=Robot1L.begin();
		}
	}
	for (itv = Robot2V.begin(); itv!=Robot2V.end(); itv++){
		if (itv->getCouleur() == 'N') {
			Robot2V.erase(itv);     
			itv=Robot2V.begin();
		}
		if (itv->getCouleur() == 'R') {
			Robot1L.insert(Robot1L.begin(), *itv);
			Robot2V.erase(itv);
			itv=Robot2V.begin();
		}
	}
}
/*
void ordre(list<boule> &tab1, vector<boule> &tab2) {//bugge
	list<boule>::iterator it1;
	vector<boule>::iterator	it2;
	cout<<"Début, on entre dans la fonction ordre"<<endl;
	for (it1 = tab1.begin(); it1 != tab1.end(); it1++) { //Ordre dans le Robot1
//		if (it1->getCouleur() == 'N') {
		if ((*it1).getCouleur() == 'N'){
			cout << "il faut faire tab1.erase(it1), car It1 sera le Noir" << endl;
//visiblement on ne passe pas dans cette branche en premier lieu mais en second lieu ! Normal car la Noire est en 3e position
//			tab1.erase(it1); //Suppression des boules noires //c'est le erase qui fait bugger
		// destruction de l'élément
        tab1.erase(it1);
 
         // et on quitte la boucle immédiatement puisqu'on a trouvé
         break;	
//avec une liste on utilise la fonction remove() ?
			
		}
		else if (it1->getCouleur() == 'B') {
			cout << "il faut faire tab2.insert(tab2.begin(),*it1), car It2 sera le Bleu" << endl;
//ici on passe bien dedans en premier lieu !
			tab2.insert(tab2.begin(),*it1);  //transfert des eventuelles boules bleues pénalisantes vers le vecteur (Robot2) 
			cout << "attention c'est à la prochaine instruction pour supprimer la boule Bleue de Robot1 que ca va planter !" << endl;
			tab1.erase(it1);//Suppression de la boule bleu de la list (Robot1) bugge mais pourquoi donc ?
//et il insère bien le contenu de it1 dans le vector Robot 2
			
//2e problème : Il n'écrase pas car il faut 
			//2 4 4 3 ==> 1 2 4 3 mais il y	a 1 2 4 4 3

		}
	}

	//Même processus pour le robot2 
	for (it2 = tab2.begin(); it2 != tab2.end(); it2++) {
//		if (it2->getCouleur() == 'N') {
		if ((*it2).getCouleur() == 'N'){
			cout << "il faut faire tab2.erase(it2), car It2 sera le Noir" << endl;
//on ne passe pas du tout dedant !	mais c'est normal car pas de boule noire dans robot2		
			//tab2.erase(it2);//c'est le erase qui fait bugger 
		// destruction de l'élément
        tab2.erase(it2); //ca bugge là aussi mais pourquoi donc ?
		}
		else if (it2->getCouleur() == 'R') {
			cout << "il faut faire tab1.insert(tab1.begin(),*it2), car It2 sera le Rouge" << endl;
//on passe dedans en 3e lieu !
			tab1.insert(tab1.begin(), *it2);
//Et il faut supprimer la boule Rouge de Robot2 après l'avoir transférée dans Robot1
			cout << "attention c'est à la prochaine instruction pour supprimer la boule Rouge de Robot2 que ca va planter !" << endl;
			tab2.erase(it2);//Bugg mais pourquoi donc ?

// et on a bien ajouté le contenu de it2 soit donc R4 au début de robot 1
		}
	}
}

*/

void ordre(list<boule> &tabRob1, vector<boule> &tabRob2) {//bugge
	list<boule>::iterator it1;
	vector<boule>::iterator	it2;
	cout<<"Début, on entre dans la fonction ordre"<<endl;
	for (it1 = tabRob1.begin(); it1 != tabRob1.end(); it1++) { //Ordre dans le Robot1
//		if (it1->getCouleur() == 'N') {
		if ((*it1).getCouleur() == 'N'){
			cout << "il faut faire tab1.erase(it1), car It1 sera le Noir" << endl;
//visiblement on ne passe pas dans cette branche en premier lieu mais en second lieu ! Normal car la Noire est en 3e position
//			tab1.erase(it1); //Suppression des boules noires //c'est le erase qui fait bugger
		// destruction de l'élément
        tabRob1.erase(it1);
		it1=tabRob1.begin();
 
         // et on quitte la boucle immédiatement puisqu'on a trouvé
         break;	
//avec une liste on utilise la fonction remove() ?
			
		}
		else if (it1->getCouleur() == 'B') {
			cout << "il faut faire tab2.insert(tab2.begin(),*it1), car It2 sera le Bleu" << endl;
//ici on passe bien dedans en premier lieu !
			tabRob2.insert(tabRob2.begin(),*it1);  //transfert des eventuelles boules bleues pénalisantes vers le vecteur (Robot2) 
			cout << "attention c'est à la prochaine instruction pour supprimer la boule Bleue de Robot1 que ca va planter !" << endl;
			tabRob1.erase(it1);//Suppression de la boule bleu de la list (Robot1) bugge mais pourquoi donc ?
//et il insère bien le contenu de it1 dans le vector Robot 2
			it1=tabRob1.begin();	
//2e problème : Il n'écrase pas car il faut 
			//2 4 4 3 ==> 1 2 4 3 mais il y	a 1 2 4 4 3
		}
	}
		//Même processus pour le robot2 
	for (it2 = tabRob2.begin(); it2 != tabRob2.end(); it2++) {
//		if (it2->getCouleur() == 'N') {
		if ((*it2).getCouleur() == 'N'){
			cout << "il faut faire tab2.erase(it2), car It2 sera le Noir" << endl;
//on ne passe pas du tout dedant !	mais c'est normal car pas de boule noire dans robot2		
			//tab2.erase(it2);//c'est le erase qui fait bugger 
		// destruction de l'élément
        tabRob2.erase(it2); //ca bugge là aussi mais pourquoi donc ?
		}
		else if (it2->getCouleur() == 'R') {
			cout << "il faut faire tab1.insert(tab1.begin(),*it2), car It2 sera le Rouge" << endl;
//on passe dedans en 3e lieu !
			tabRob1.insert(tabRob1.begin(), *it2);
//Et il faut supprimer la boule Rouge de Robot2 après l'avoir transférée dans Robot1
			cout << "attention c'est à la prochaine instruction pour supprimer la boule Rouge de Robot2 que ca va planter !" << endl;
			tabRob2.erase(it2);//Bugg mais pourquoi donc ?

// et on a bien ajouté le contenu de it2 soit donc R4 au début de robot 1
		}
	}
}
//Case 5 - Copie
list<int> copie (list<boule> robot1,vector<boule> robot2/*, list<boule> &liste2*/){//ne pas passer liste2 par paramètres !on fait la copie dans le main
	list<boule>::iterator itl1;
	vector<boule>::iterator itv2;
	list<int> listeValeurs;
	//d'abord copier le vector Robot2
	for (itv2 = robot2.begin(); itv2 != robot2.end(); itv2++)
	{
		listeValeurs.insert(listeValeurs.end(),itv2->getVal());
	}
	//ensuite copier la list Robot1
	for (itl1 = robot1.begin(); itl1 != robot1.end() ; itl1++)
	{
		listeValeurs.insert(listeValeurs.end(),itl1->getVal());
	}
	return listeValeurs;
}


void copieNum(vector<boule>V, list<boule>L, list<int>&list2){
	list2.clear();
	vector<boule>::iterator itv;
	list<boule>::iterator itl;

	for (itv = V.begin(); itv!=V.end(); itv++){
		list2.push_back(itv->getVal());	
	}
	for (itl = L.begin() ; itl!= L.end(); itl++){
		list2.push_back(itl->getVal());
	}
}

/*
template <classe X> void copieNumT(X tab, list<int>&list2){
//	list2.clear();//surtout pas avec le template sinon après le 1er appel, au 2e rien ne sera sauvé
	X::iterator it;
	
	for (it = tab.begin(); it!=tab.end(); it++){
		list2.push_back(it->getVal());	
	}
}
*/
void afficherListe2(list<int> liste2){
	list <int>::iterator it;
	for (it = liste2.begin(); it != liste2.end(); it++)
	{
		cout<<*it<<endl;
	}
}

void AFF_List2(list<int> list2, string S){//j'avais pas mis #include <string> dans l'entête donc erreur suivante :
	//Erreur	1	error C2679: '<<' binaire : aucun opérateur trouvé qui accepte un opérande de partie droite de type 'std::string' (ou il n'existe pas de conversion acceptable)

	list <int>::iterator it;
	for (it = list2.begin(); it != list2.end(); it++)
	{
		cout <<"List2 après"<<endl;
		cout << S <<endl;
		cout <<"+ Affichage:"<<endl;
		cout <<*it<<endl;
	}

}

//Case 6 - Permuter Robot1_L et Robot2_V

void permuterLEtV(list<boule> L, vector<boule> V){
	list<boule> Robot1, tmperm1;
	vector<boule> Robot2, tmperm2;
	 
	tmperm2=Robot2;					//pour ne pas perdre les données
	tmperm1=Robot1;					//avant de resizer

	Robot1.resize(Robot2.size());	//redéfinition de la taille
	copy(Robot2.begin(), Robot2.end(), Robot1.begin());	//algorithm

	Robot2.resize(tmperm1.size());	//redéfinition de la taille
	copy(tmperm1.begin(), tmperm1.end(), Robot2.begin());	//algorithm
}

//Fct de comparaison pour l'ordre décroissant
bool cmp(int a, int b){
	return a>b;//sens du TRI décroissant
}

void menu(int &choix){
    cout << "Votre choix?...= " << endl;
	cout << "1- SaisieRobot1_L et Affichage" << endl;
	cout << "2- SaisieRobot2_V et Affichage" << endl;
	cout << "3- Qui est le gagnant?" << endl;
	cout << "4- Mettre de l'ordre" << endl;
	cout << "5- Copie des numeros de Robot1 et Robot2 dans la liste2 + tri + Affichage, supprimer les doublons + Affichage" << endl;
	cout << "6- Permuter Robot1_L et Robot2_V" << endl;
	cout << "7- Affichage Robot1_L et Robot2_V" << endl;
	cout << "8- Quitter" << endl;
    cin>>choix;

    if (cin.fail()){
        cin.clear();
        cin.ignore();
        cin>>choix;
    }
}
int main(){
	setlocale(LC_ALL, "fra");  //Pour les accents
    //déclaration des variables
	int choix, sommeRobot1=0, sommeRobot2=0;
	boule robot1, robot2;
	list<boule> L;
	vector<boule> V;
	list<boule>::iterator itl;
	vector<boule>::iterator itv;
	list<int> liste2;
	list<int> list2;

	string S=0;
//	char RB='v';
	int somRobot1=0, somRobot2=0;
	int som=0;

    //Sélection d'un choix par l'utilisateur
    do{
        
        menu(choix);
        switch(choix)
            {
                case 1:
                    cout << "C'est bien le choix 1- SaisieRobot1_L et Affichage" << endl;
//					saisieRobot1List(L);
					saisieRobot<list<boule>, string >(L,"Combien de boules voulez-vous que Robot1 saisisse ?");
//                  afficheRobot1List(L);
					afficheRobot<list<boule>, list<boule>::iterator>(L,itl,"Affichage Robot1_L");
					break;
                case 2:
                    cout << "C'est bien le choix 2- SaisieRobot2_V et Affichage" << endl;
//					saisieRobot2Vector(V);
					saisieRobot<vector<boule>, string >(V,"Combien de boules voulez-vous que Robot2 saisisse ?");
//					afficheRobot2Vector(V);
					afficheRobot<vector<boule>, vector<boule>::iterator>(V,itv,"Affichage Robot2_V");					
					break;
                case 3:
                    cout << "C'est bien le choix 3- Qui est le gagnant?" << endl;
//					somme(L,V,sommeRobot1,sommeRobot2);
					somme<list<boule>,list<boule>::iterator,const char[2]>(L,itl,"R");
//					somme<list<boule>,char>(L,"R");
					somRobot1=som;
					somme<vector<boule>,vector<boule>::iterator,const char[2]>(V,itv,"B");
//					somme<vector<boule>,char>(V,"B");
					somRobot2=som;
					
					if (somRobot1>somRobot2)
					{
						cout<<"Le gagnant est Robot1"<<endl;
					}
					if (somRobot1<somRobot2)
					{
						cout<<"Le gagnant est Robot2"<<endl;
					}
					if (somRobot1==somRobot2)
					{
						cout<<"Ex aequo"<<endl;
					}
					/*
					if (sommeRobot1>sommeRobot2)
					{
						cout<<"Le gagnant est Robot1"<<endl;
					}
					if (sommeRobot1<sommeRobot2)
					{
						cout<<"Le gagnant est Robot2"<<endl;
					}
					if (sommeRobot1==sommeRobot2)
					{
						cout<<"Ex aequo"<<endl;
					}
					*/
					break;
                case 4:
                    cout << "C'est bien le choix 4- Mettre de l'ordre" << endl;
                    
					break;
                case 5:
                    cout << "C'est bien le choix 5- Copie des numeros de Robot1 et Robot2 dans la liste2 + tri + Affichage, supprimer les doublons + Affichage" << endl;
					cout << "Affichage List Robot1 et Vector Robot2 avant copie" << endl;
					afficheRobot(L,itl,"Affichage Robot1_L");
					afficheRobot(V,itv,"Affichage Robot2_V");			
					liste2 = copie(L,V);
					copieNum(V, L, list2);
//					afficherListe2(liste2);
					AFF_List2(list2,"Après Copie");
					cout << "Liste2 après Tri décroissant + Affichage" << endl;
					list2.sort(cmp);//on passe cmp car le sort() de base trie dans l'ordre croissant
//					liste2.sort(cmp);//on passe cmp car le sort() de base trie dans l'ordre croissant
//					afficherListe2(liste2);
					AFF_List2(list2,"Tri décroissant");
					cout << "Liste2 après Supprimer les doublons +Affichage :" << endl;
					list2.unique();
					AFF_List2(list2,"sans doublons");
					break;
                case 6:
                    cout << "C'est bien le choix 6- Permuter Robot1_L et Robot2_V" << endl;
                    permuterLEtV(L,V);
					break;
                case 7:
                    cout << "C'est bien le choix 7- Affichage Robot1_L et Robot2_V" << endl;
					afficheRobot(L,itl,"Affichage Robot1_L");
					afficheRobot(V,itv,"Affichage Robot2_V");			
					break;
                case 8:
                    cout << "C'est bien le choix 8- Quitter" << endl;
                    break;
                
            }//fin switch
        }while(choix!=8);//fin boucle do ... while


    return 0;
}