#include "algo.h"
#include<fstream>
#include<iostream>

void algo::lecture(string nom_fic)
{
	int nb_objets,nb_proprietes;
	fstream fic;
	
	int val;
	
	
	fic.open(nom_fic.c_str(),ios::in);
	if (fic.fail())
		cout<<"fichier d'entree inexistant. ";
			
	else
	{
			
  		fic>>nb_objets;
  		fic>>nb_proprietes;

		for(int k=0;k<nb_objets;k++) relation_a_examiner.objets.push_back(k);
		for(int l=0;l<nb_proprietes;l++) relation_a_examiner.proprietes.push_back(nom_propriete(l+1));
   		for(int i=0;i<nb_objets;i++)
		{
			vector <int> objet;
			for(int j=0;j<nb_proprietes;j++)
				{
					fic>>val;
					objet.push_back(val);
				}
			relation_a_examiner.tableau.push_back(objet);
		}
	}
	// Affichage de la relation
	char rep;
	do{
		cout<<"Voulez-vous afficher la relation ? (o/n) : ";
		cin>>rep;
		cout<<endl;
	}while (rep!='o' && rep!='O' && rep!='n' && rep!='N');
	if(rep=='o' || rep=='O')
	{
		system("cls");
		relation_a_examiner.afficher();
		system("pause");
		system("cls");
	}

}

string algo::nom_propriete(int num)
{
	string res;
	while (num>0)
	{
		switch(num%26)
		{
		case 0: 
			{
				res=res+'z';
				num=num-26;
				break;
			}
		case 1: 
			{
				res=res+'a';
				num=num-26;
				break;
			}
		case 2: 
			{
				res=res+'b';
				num=num-26;
				break;
			}
		case 3: 
			{
				res=res+'c';
				num=num-26;
				break;
			}
		case 4: 
			{
				res=res+'d';
				num=num-26;
				break;
			}
		case 5: 
			{
				res=res+'e';
				num=num-26;
				break;
			}
		case 6: 
			{
				res=res+'f';
				num=num-26;
				break;
			}
		case 7: 
			{
				res=res+'g';
				num=num-26;
				break;
			}
		case 8: 
			{
				res=res+'h';
				num=num-26;
				break;
			}
		case 9: 
			{
				res=res+'i';
				num=num-26;
				break;
			}
		case 10: 
			{
				res=res+'j';
				num=num-26;
				break;
			}
		case 11: 
			{
				res=res+'k';
				num=num-26;
				break;
			}
		case 12: 
			{
				res=res+'l';
				num=num-26;
				break;
			}
		case 13: 
			{
				res=res+'m';
				num=num-26;
				break;
			}
		case 14: 
			{
				res=res+'n';
				num=num-26;
				break;
			}
		case 15: 
			{
				res=res+'o';
				num=num-26;
				break;
			}
		case 16: 
			{
				res=res+'p';
				num=num-26;
				break;
			}
		case 17: 
			{
				res=res+'q';
				num=num-26;
				break;
			}
		case 18: 
			{
				res=res+'r';
				num=num-26;
				break;
			}
		case 19: 
			{
				res=res+'s';
				num=num-26;
				break;
			}
		case 20: 
			{
				res=res+'t';
				num=num-26;
				break;
			}
		case 21: 
			{
				res=res+'u';
				num=num-26;
				break;
			}
		case 22: 
			{
				res=res+'v';
				num=num-26;
				break;
			}
		case 23: 
			{
				res=res+'w';
				num=num-26;
				break;
			}
		case 24: 
			{
				res=res+'x';
				num=num-26;
				break;
			}
		case 25: 
			{
				res=res+'y';
				num=num-26;
				break;
			}
		}
	}

	return res;
}


// Algorithme de Ganter

//Procédure permettant d'initialiser le vecteur A caractérisant les parties
//des intensions calculées par l'algorithme de Ganter
void algo::init(vector<int>&A,const int & nbpropriete, const int & valeur)
{
	int i;
	
	A.resize(nbpropriete);
	for(i=0;i<nbpropriete;i++)
		A[i]=valeur;
}


/*Fonction permettant de retourner l'indice du dernier 0 dans le vecteur A
à partir du rang k de ce vecteur (retourne -1 si il n'y a pas de 0*/
int algo::test(const vector<int> & A,const int & k,const int & nbpropriete)
{
	int i=-1;
	int j=k;

	while (j<nbpropriete)
	{
		if (A[j]==0)
			i=j;
		j++;
	}
	return i;
}

/* fonction permettant de tester si l'indice j, c'est-à-dire l'indice tel que 
A <j Aprim, est supérieur à l'indice courant i*/
bool algo::test_isupj(const vector<int> & A, const vector<int> & Aprim, const int & nbpropriete, const int & i)
{
	int j=nbpropriete; //initialiser à cette valeur pour le cas d'un fermé ( on doit avoir false)
	int k=0;
	int vide=1;
	
	//on teste si Aprim est composé uniquement de 0, donc si il est égale au vide 
	while((k<nbpropriete) && (vide==1))
	{
		if(Aprim[k]!=0)
			vide=0;
		k=k+1;
	}
	//si c'est le cas alors i>j (on peut concidérer que j=0)
	if (vide==1)
	{
		return true;
	}
	else
	{
		k=0;
		while((k<nbpropriete) && (j==nbpropriete))
		{
			if (Aprim[k] > A[k])
				j=k;
			k=k+1;
		}
		if (i<j) 
			return	false;
		else
			return true;
	}
}

/* Fontion qui test si A est un fermé ou non. Pour cela, elle calcule Aprim qui est égale 
à h'(A), puis elle test si A est égale à Aprim.De plus, on obtient le vecteur ext représentant
l'extension de l'intension caractérisée par le vecteur A*/
void algo::calcul_h_prim(const vector<int> & A, vector<int> &Aprim, vector<int> &ext, const int & nbpropriete, const int & nbobjet,const vector<vector<int> > & rel)
{
    int i,j,rep;
	int prem=1;
	int ferm=1;
	int testA=1;
	int testext=1;

	//on réinitialise Aprim
	for(i=0;i<nbpropriete;i++)
		Aprim[i]=0;
	//on calcule le vecteur ext à partir du vecteur A
	for(i=0;i<nbobjet;i++)
	{
		j=0;
		rep=1;
		while((j<nbpropriete) && (rep==1))
		{
			// lorsque l'élément du vecteur A vaut 1,
			//on test la valeur de la ligne i et la colonne j de la relation
			if((A[j]==1) && (rel[i][j]==0))
				rep=0;
			j=j+1;
		}
		//si pour la ligne i de la relation, lorsqu'on a A[j] vaut 1,on a une valeur de 
		//1 pour toutes les colonnes j alors ext[i] prend la valeur 1
		if (rep==1)
		{
			ext[i]=1;
			//testext=0;//on teste si le vecteur ext est composé uniquement de 0
		}
		//si pour la ligne i de la relation, lorsqu'on a A[j] vaut 1, on a une valeur de 
		// 0 pour la colonne j alors ext[i] prend la valeur 0
		else
			ext[i]=0;
	}
	//on calcule Aprim à partir de ext
	for(i=0;i<nbobjet;i++)
	{
		//pour cela, on n'utilise les lignes i de la relation si ext[i]=1
		if (ext[i]==1)
		{
			//si c'est la première fois que l'on rencontre une valeur de 1 pour
			//le vecteur ext, on initialise Aprim par la ligne i de la relation
			if (prem==1)
			{
				for(j=0;j<nbpropriete;j++)
				{
					Aprim[j] = rel[i][j];
				}
				prem=0;
			}
			//si ce n'est pas la première fois, si Aprim[j] et la valeur de la ligne i de  
			// et de la colonne j de la relation alors Aprim[j] prend la valeur 0
			else
			{
				for(j=0;j<nbpropriete;j++)
				{
					if (Aprim[j]!=rel[i][j])
						Aprim[j]=0;
				}
			}
		}
	}
}

//Prcocédure permettant d'afficher le vecteur A
void algo::affiche_a(const vector<int> & A,const  int & nbpropriete)
{
	int i;

	for(i=0;i<nbpropriete;i++)
	{
		cout<<A[i]<<", ";
	}
	cout<<endl;
}


//Procédure permettant d'afficher le résultat obtenu par l'algorithme de Ganter,
//sous forme de concepts
void algo::affiche_resultat(list <vector<int> >  Lferme, list<vector<int> >  Lext, const int & nbpropriete, const int & nbobjet)
{
	list<vector<int> > ::iterator itf,ite;
	int i,j;
	int test;//permet de tester le cas vide * 1..nbpropriete
	
	itf=Lferme.begin();
	ite=Lext.begin();
	//affiche le concept vide * 1..nbpropriete qui est toujours le premier de la
	//liste car c'est c'est le vecteur initiale de l'algorithme de Ganter
	cout<<"vide * ";
	for(j=0;j<nbobjet;j++)
	{
			if((*ite)[j]==1)
			{
				cout<<j+1;
			}
	}
	cout<<endl;
	if (itf!=Lferme.end())
		itf++;
	if (ite!=Lext.end())
		ite++;
	while ((itf!=Lferme.end()) && (ite!=Lext.end()))
	{
		//affiche l'intension du concept
		for(i=0;i<nbpropriete;i++)
		{
			if((*itf)[i]==1)
			{
				cout<<nom_propriete(i+1);
			}
		}
		cout<<" * ";
		test=1;
		//affiche l'extension du concept
		for(j=0;j<nbobjet;j++)
		{
			if((*ite)[j]==1)
			{
				cout<<j+1;
				test=0;
			}
		}
		//si le vecteur ext est composée uniquement de 0 
		//alors l'extension du concept est le vide
		if (test==1)
		{
			cout<<"vide";
		}
		cout<<endl;
		itf++;
		ite++;
	}
}


//Procédure permettant de sauver le résultat obtenu par l'algorithme de Ganter,
//sous forme de concepts
void algo::sauve_resultat(list <vector<int> >  Lferme, list<vector<int> >  Lext, const int & nbpropriete, const int & nbobjet, string text)
{
	list<vector<int> > ::iterator itf,ite;
	int i,j;
	int test;//permet de test le cas vide * 1..nbpropriete
	
	//ouverture du fichier
	ofstream fic(text.c_str());

	if (!fic)
	{
		cout<<"Impossible de créer le fichier !"<<endl;
		cout<<endl;
		system("pause");
		system("cls");
		exit(1);
	}

	fic<<"Voici les concepts de la relation:"<<endl;
	itf=Lferme.begin();
	ite=Lext.begin();
	//sauve le concept vide * 1..nbpropriete qui est toujours le premier de la
	//liste car c'est c'est le vecteur initiale de l'algorithme de Ganter
	fic<<"vide * ";
	for(j=0;j<nbobjet;j++)
	{
			if((*ite)[j]==1)
			{
				fic<<j+1;
			}
	}
	fic<<endl;
	if (itf!=Lferme.end())
		itf++;
	if (ite!=Lext.end())
		ite++;
	while ((itf!=Lferme.end()) && (ite!=Lext.end()))
	{
		//sauve l'intension du concept
		for(i=0;i<nbpropriete;i++)
		{
			if((*itf)[i]==1)
			{
				fic<<nom_propriete(i+1);
			}
		}
		fic<<" * ";
		test=1;
		//affiche l'extension du concept
		for(j=0;j<nbobjet;j++)
		{
			if((*ite)[j]==1)
			{
				fic<<j+1;
				test=0;
			}
		}
		//si le vecteur ext est composée uniquement de 0 
		//alors l'extension du concept est le vide
		if (test==1)
		{
			fic<<"vide";
		}
		fic<<endl;
		itf++;
		ite++;
	}
	fic.close();
}

//procédure permettant d'appliquer l'algorithme de Ganter et d'obtenir la liste des fermés
//de la relation, ainsi que leur extension
void algo::lancer_algo_ganter(list <vector<int> > &Lferme, list <vector<int> > &Lext, int &nbpropriete, int &nbobjet)
{
	int i,j,k,l,k_temp,arret;
	bool isupj;
	vector<int> A;
	vector<int> Aprim;
	vector<int> ext;
	int test1=1;
	
	nbpropriete = relation_a_examiner.proprietes.size();
	nbobjet = relation_a_examiner.objets.size();

	init(A,nbpropriete,0);//car A est un fermé
	init(ext,nbobjet,1);
	Lferme.push_back(A);
	Lext.push_back(ext);
	init(Aprim,nbpropriete,0);
	//permet d'obtenir le premier vecteur A pour l'indice k étudié par l'algorithme
	//pour cela on A[k] qui vaut 1 et tout le rest qui vaut 0
	for(k=nbpropriete-1; k >= 0; k--)
	{
		A[k]=1;
		for(l=k+1;l<nbpropriete;l++)
		{
			A[l]=0;
		}
		i=k;
		//on calcule h'(A)
		calcul_h_prim(A,Aprim,ext,nbpropriete,nbobjet,relation_a_examiner.tableau);
		//on test si le vecteur A obtenu est un fermé ou non
		if (test_isupj(A,Aprim,nbpropriete,i)==false)
		{
			Lferme.push_back(Aprim);
			Lext.push_back(ext);
			A=Aprim;
			//affiche_a(A,nbpropriete);
			//affiche_a(Aprim,nbpropriete);
			//cin>>arret;
		//}
			//pas besion de calculer si i>j, car dans les deux cas on passe au suivant
			//c'est-à-dire si i<j alors i prend la valeur du plus grand indice de A tel que
			// la valeur de A est 0 et de même si i>j, donc on ne teste pas si i<j
			i=nbpropriete+1;
			k_temp=k;
			while(i>k)	// *1
			{		
				//cherche le plus indice de A dont la valeur est 0 après l'indice k
				i = test(A,k_temp,nbpropriete);
				//si il n'y en a pas on passe à k suivant
				if (i==-1)
					i=k;
				else
				{
					//si il existe, A[i] prend la valeur 1 et pour tout l>i A[l]=0
					A[i]=1;
					for(l=i+1;l<nbpropriete;l++)
						A[l]=0;
					//on calcule h'(A)
					calcul_h_prim(A,Aprim,ext,nbpropriete,nbobjet,relation_a_examiner.tableau);
					//on test si A est un fermé
					isupj=test_isupj(A,Aprim,nbpropriete,i);
					if(isupj==false)
					{
						//si c'est le cas, on l'ajoute à la liste et on ne teste pas si i>j 
						//car c'est obligatoirement faut (A[i]=Aprim[i] pour tout i)
						Lferme.push_back(Aprim);
						Lext.push_back(ext);
						A=Aprim;
						//affiche_a(A,nbpropriete);
						//cin>>arret;
					}
					else
					{
						//si il n'est pas fermé
						//isupj=test_isupj(A,Aprim,nbpropriete,i);
						while( isupj == true)	// *2
						{ 
							//si c'est le cas, on passe à l'indice i suivant, c'est-à-dire,
							//le plus grand indice j tel que j<i, A[j]=0 et j >-1 
							i=i-1;
							while((A[i]==1) && (i>-1))
								i=i-1;
							//on teste si le nouvel indice est supérieur à k
							if (i>k_temp)
							{
								//si c'est le cas on calcule le nouveau vecteur A (comme
								//précédemment)
								A[i]=1;
								for(l=i+1;l<nbpropriete;l++)
									A[l]=0;
								//on calcule h'(A)
								calcul_h_prim(A,Aprim,ext,nbpropriete,nbobjet,relation_a_examiner.tableau);
								//on test si A est fermé ou non
								isupj=test_isupj(A,Aprim,nbpropriete,i);
								if(isupj==false)
								{
									Lferme.push_back(Aprim);
									Lext.push_back(ext);
									A=Aprim;						
									//affiche_a(A,nbpropriete);
									//cin>>arret;
								}
								//Puis on test si i>j
								//isupj=test_isupj(A,Aprim,nbpropriete,i);
							}
							else
							{
								//si ce n'est pas le cas on initialise isupj à false pour sortir 
								//de la boucle while 2. puis on sort de la boucle while 1 car i<k
								// et on passe au k suivant
								isupj=false;
							}
						}
					}			
				}
			}
		}
	}
	//permet de générer le concept abcde... * vide s'il existe 
	j=0;
	while((j<nbobjet) && (test1==1))
	{
		if (ext[j]!=0)
			test1=0;
		j=j+1;
	}
	if (test1==1){
		for(j=0;j<nbpropriete;j++)
			Aprim[j]=1;
		Lferme.push_back(Aprim);
		Lext.push_back(ext);
	}
	A.clear();
	Aprim.clear();
	ext.clear();
}