#include <iostream>
#include <stdio.h>
#include <fstream>
#include <string>
#include "Conjunto.h"
#include "Processor.h"

///////////////////////////////////////////////////////////////////////////////////////////////////////


//                                                FUNCIONES


///////////////////////////////////////////////////////////////////////////////////////////////////////


void manejo(ifstream & infile)
{


	///////////////////////////////////////////////////////MATRIZ DONDE GUARDO LOS CONJUNTOS DEL ARCHIVO

	char MAT_CONJ[100][100];// defino matriz para guardar los caractres de los conjuntos
	
	int in_lin_mat_conj=0; 
	int in_col_mat_conj=0;
	int number=0;
	int cuenta=0;


	Conjunto ARR_CONJ[100];//defino arreglo de conjuntos
	
	infile >> MAT_CONJ[0];//meto a mi matriz la primera linea del archivo 

	while('%' != MAT_CONJ[in_lin_mat_conj][0])
	{
		in_col_mat_conj=0;

		while('{' != MAT_CONJ[in_lin_mat_conj][in_col_mat_conj])
		{
			in_col_mat_conj++;
		}
		in_col_mat_conj++;
		
		while('}' != MAT_CONJ[in_lin_mat_conj][in_col_mat_conj])
		{
			number=0;
			if((MAT_CONJ[in_lin_mat_conj][in_col_mat_conj]<'0')||(MAT_CONJ[in_lin_mat_conj][in_col_mat_conj]>'9'))
			{
				in_col_mat_conj++;
			}
			else
			{
				while((MAT_CONJ[in_lin_mat_conj][in_col_mat_conj]>='0')&&(MAT_CONJ[in_lin_mat_conj][in_col_mat_conj]<='9'))
				{
					number=number*10+MAT_CONJ[in_lin_mat_conj][in_col_mat_conj]-'0';
					in_col_mat_conj++;
				}
				ARR_CONJ[in_lin_mat_conj].agrega(number);
			}
		}
		
		in_lin_mat_conj++;
		infile >> MAT_CONJ[in_lin_mat_conj];
		} 
		

///////////////// lleno con las definiciones de los conjuntos del archivo mi matriz de caracteres	
	
	///////////////////////////////////////////////////MATRIZ DONDE GUARDO LAS OPERACIONES DEL ARCHIVO
		
	
	
		int i=0;
		char MAT_OPERACIONES[100][100];//defino matriz de operaciones
		string STR_RESP;//defino string de respuestas
		infile>>MAT_OPERACIONES[i];
		
		while(!infile.eof())
		{
			cout<<"CONJUNTOS:"<<"\n"<<endl;
			for(int x=0;x<in_lin_mat_conj;x++)
			{
				if(x==in_lin_mat_conj-1)
				{
					cout<<MAT_CONJ[x]<<"\n"<<endl;
				}
				else
				{
					cout<<MAT_CONJ[x]<<endl;
				}
			
			}
			cout<<"OPERACION:"<<"\n"<<endl;
			
			cout<<MAT_OPERACIONES[i]<<"\n"<<endl;
			Processor p(MAT_OPERACIONES[i],  ARR_CONJ, MAT_CONJ);
			cout<<"ESCRIBA LA RESPUESTA EN LA FORMA {x,y,z,...}:  \n"<<endl;
			getline(cin,STR_RESP);
			int w=0;
			Conjunto temp;
			Conjunto rc;
			
			while('}' != STR_RESP[w])
			{
				int k=0;
				if((STR_RESP[w]<'0')||(STR_RESP[w]>'9'))
				{
					w++;
				}
				else
				{
					while((STR_RESP[w]>='0')&&(STR_RESP[w]<='9'))
					{
						k=k*10+STR_RESP[w]-'0';
						w++;
					}
					temp.agrega(k);
				}
			}
			
			cout<<"El resultado correcto es el siguiente:\n"<<endl;
			rc=p.RES_CORRECTO();
			int f=rc.Compara(temp);
			rc.Display();
			
			if(f==1)
			{   cout<<"Su respuesta fue correcta\n"<<endl;
				cuenta=cuenta+1;
			}
			
			else
			{
				cout<<"Su respuesta fue errada\n"<<endl;
			}

			i++;
			infile>>MAT_OPERACIONES[i];
		}

		double porcentage_exito;
		porcentage_exito=100*cuenta/i;
		cout<<"el numero de repuestas correctas fue: "<<cuenta<<"\n"<<endl;
		cout<<"Su porcentaje de éxito es ="<<" "<<porcentage_exito<<"%"<<"\n"<<"\n"<<endl;
}

////////////////////////////////////////////////////////////////////////////////////////

void runtest(char *test, int j, int f)
{
	int a=0,b=0,c=0,d=1,a3=1,r3=1;
	
	//detecta operaciones al comienzo o final//
	int a1=((test[0]=='+')||(test[0]=='*'));
	int l2=((test[f-2]=='+')||(test[f-2]=='*'));
	if((a1||l2)==1)
		{
			cout<<"Error, operacion presente al inicio o final de la linea "<<j<<":"<<endl;
			a3=0;
			for(int h=0;h<f;h++)
				printf("%c",test[h]);
			printf("\n\n");
		}

	//chequea que los parentesis esten balanceados//
	for(int r=0;r<f;r++)
	{
		if(test[r]=='(')
			a++;
		else if(test[r]==')')
			b++;
	}
	if(a!=b)
	{
		cout<<"Error, parentesis no balanceados en la linea "<<j<<":"<<endl;
		for(int h=0;h<f;h++)
			printf("%c",test[h]);
		printf("\n\n");
	}
	else
		c=1;
	//chequea que las operaciones esten escritas correctamente//
	for(int s=0;s<f;s++)
	{
		int q=((test[s]=='+')||(test[s]=='*'));
		int w=((test[s+1]=='+')||(test[s+1]=='*'));
		if((q&&w)==1)
		{
			cout<<"Error, operacion repetida en la linea "<<j<<":"<<endl;
			d=0;
			for(int h=0;h<f;h++)
				printf("%c",test[h]);
			printf("\n\n");
		}
	}
	//chequea que no exista cierre de parentesis seguido de una letra o dos letras consecutivas sin operacion de por medio//
	for(int z1=0;z1<f;z1++)
	{
		int r1=((test[z1]==')')||((test[z1]>='A')&&(test[z1]<='Z')));
		int r2=(((test[z1+1]>='A')&&(test[z1+1]<='Z'))||(test[z1+1]=='('));
		if((r1&&r2)==1)
		{
			cout<<"Error, operacion ausente entre un cierre o apertura de parentesis y un conjunto en la linea "<<j<<":"<<endl;
			r3=0;
			for(int h=0;h<f;h++)
				printf("%c",test[h]);
			printf("\n\n");
		}
	}
	if(c&&d&&a3&&r3)
		cout<<"linea "<<j<<" escrita correctamente"<<'\n'<<endl;
}

//contador de operaciones a realizar para determinar cuantas lineas hay que revisar sintacticamente//
int opcount(ifstream &arch)
{
	char ayuda[50];
	char l='%';
	int i=0;
	while(!arch.eof())
	{
		arch>>ayuda;
		if(ayuda[0]==l)//detecta la linea de separacion entre conjuntos y operaciones//
			goto cuenta;
	}
cuenta:;
	while(!arch.eof())
	{
		arch>>ayuda;//cuenta lineas con operaciones//
		i++;
	}
	return i;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


//                                                        MAIN


/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////




int main (int argc, char * argv[]) 
{
	if((argc!=2)&&(argc!=3))
	{
		
    		cerr << "ERROR "<< "Número de argumentos invalidos en la linea de comandos\n" << endl;
    		return 1;
	}	


		
	
	if(argc==2)
	{   
		ifstream fin;
		fin.open(argv[1]);
		manejo(fin);
		fin.close();
	}

	else if((argc==3))
	{
		cout<<'\n'<<"Iniciando revision de sintaxis..."<<'\n'<<endl;
		ifstream fin,know;
		int i=0,k=0,b;
		char operaciones[50];
		char basura[50];
		char j='%';

		fin.open(argv[1]);
		know.open(argv[1]);
		b=opcount(know);//nº lineas de operaciones en el archivo

		while(basura[0]!=j)
		{
			fin>>basura;
		}

		for(int z=0;z<b-1;z++,k=0)
		{
			for(int g=0;g<50;g++)
			{
				operaciones[g]='i';
			}
			fin>>operaciones;

			while(operaciones[k]!='i')
			{
				k++;
			}			
				i++;
			runtest(operaciones, i, k);
		}
		cout<<"Revision de sintaxis completada."<<endl;
	}
}