/*!\file check.c
 *
 * \author SOUPLET Antoine
 * \version 1.0
 * \date 10-01-2012 
 *
 * \brief Fichier contenant les fonctions de vérification de la justesse des lignes écrites dans les fichiers L-System et Flamme
 *
 */

#include "functionAdd.h"
#include <stdio.h>
#include "check.h"
#include "postfix.h"
#include <stdlib.h>
#include <string.h>

//Teste si la chaine de caractère correspondant au numéro de la ligne du fichier passée en paramètre est correcte
void testCorrectFlameFunction(char* pc_function, char* pc_fileName, int i_line) {
	int i;//entier, variable de boucle
	testCorrectParenthesis(pc_function, pc_fileName, i_line);//Vérifie que la syntaxe des parenthèses dans la ligne du fichier est correcte
	for (i = 0; i < strlen(pc_function); i++) {
		if (!(0<=pc_function[i]-48 && pc_function[i]-48<10)) {//Si le caractère en cours de lecture n'est pas un chiffre, on vérifie que c'est un caractère permit
			i=i+isAllowChar(pc_fileName, i_line, i, pc_function)-1;
		}
	}
}


//Teste si la syntaxe des parenthèses dans la ligne du fichier passée en paramètre est correcte
void testCorrectParenthesis(char* pc_function, char* pc_fileName, int i_line) {
	int i;//entier, variable de boucle
	int i_parenthesisNumber;//entier correspondant au nombre de parenthèses ouvrantes non fermées 
	i_parenthesisNumber=0;
	for (i = 0; i < strlen(pc_function); i++) {
		if (pc_function[i]=='(') {//Si le caractère en cours de lecture est une paranthèse ouvrante, on incrémente le nombre de parenthèses ouvrantes non fermées
			i_parenthesisNumber++;
		}
		else if (pc_function[i]==')') {//Si le caractère en cours de lecture est une parenthèse fermante, on décrémente le nombre de parenthèses ouvrante non fermées
			i_parenthesisNumber--;
		}
	}
	if (i_parenthesisNumber!=0) {//Si le nombre de parenthèses ouvrante non fermées est différent de 0, alors il y a une erreur de syntaxe au niveau des parenthèses et on quitte donc le programme en affichant un message d'erreur
		exitErrorSyntaxParenthesis(pc_fileName, pc_function, i_line);
	}
}

//Teste si un caractère est permit, c'est à dire s'il correspond à un opérateur, un opérande pré-enregistré, un chiffre ou une parenthèse
int isAllowChar(char* pc_fileName, int i_line, int i_pos, char* pc_function) {
	switch(pc_function[i_pos]) {
		case 'c': return(isCorrectCos(pc_fileName, i_line, i_pos, pc_function));
			  break;
		case 's': return(isCorrectSin(pc_fileName, i_line, i_pos, pc_function));
			  break;
		case 't': return(isCorrectTan(pc_fileName, i_line, i_pos, pc_function));
			  break;
		case 'a': return(isCorrectArc(pc_fileName, i_line, i_pos, pc_function));
			  break;
		case 'e': return(isCorrectExp(pc_fileName, i_line, i_pos, pc_function));
			  break;
		case 'h': return(isCorrectHyp(pc_fileName, i_line, i_pos, pc_function));
			  break;
		case 'X': return (isCorrectOperand(pc_fileName, i_line, i_pos, pc_function));
			  break;
		case 'Y': return (isCorrectOperand(pc_fileName, i_line, i_pos, pc_function));
			  break;
		case 'P': return(isCorrectPi(pc_fileName, i_line, i_pos, pc_function));
			  break;
		case 'S': return(isCorrectSqrt(pc_fileName, i_line, i_pos, pc_function));
			  break;
		case 'R': return (isCorrectOperand(pc_fileName, i_line, i_pos, pc_function));
			  break;
		default:{//Si le caratère ne correspond pas aux précédents cas du switch, alors on teste si celui ci correspond à un opérateur différent ou à une parenthèse
				return isAllowOperatorOrParenthesis(pc_fileName, i_line, i_pos, pc_function);
			}
	}
}


//Teste si la fonction cosinus reconnue par l'analyseur syntaxique est correcte
int isCorrectCos(char* pc_fileName, int i_line, int i_pos, char* pc_function) {
	if(strlen(pc_function) >= i_pos +4) {
		if (pc_function[i_pos+1]=='o' && pc_function[i_pos+2]=='s'&& pc_function[i_pos+3]=='(' && !isParticularOperatorBinary(pc_function[i_pos+4])) {
			return (4);	
		} else {
			exitErrorSyntax(pc_fileName, pc_function, i_line, i_pos, i_pos+4);
			return (-1);
		}
	}
	exitErrorSyntax(pc_fileName, pc_function, i_line, i_pos, strlen(pc_function));//si il y a une erreur de syntaxe, on quitte le programme après avoir affichée une erreur précisant la position du caractère à problème, la ligne et le fichier contenant l'erreur
	return (-1);
}


//Teste si la fonction sinus reconnue par l'analyseur syntaxique est correcte
int isCorrectSin(char* pc_fileName, int i_line, int i_pos, char* pc_function) {
	if(strlen(pc_function)>= i_pos +4) {
		printf("1\n");
		if (pc_function[i_pos+1]=='i' && pc_function[i_pos+2]=='n' && pc_function[i_pos+3]=='(' && !isParticularOperatorBinary(pc_function[i_pos+4])) {
			return (4);	
		} else {
			exitErrorSyntax(pc_fileName, pc_function, i_line, i_pos, i_pos+4);
			return (-1);
		}
	}
	exitErrorSyntax(pc_fileName, pc_function, i_line, i_pos, strlen(pc_function));//si il y a une erreur de syntaxe, on quitte le programme après avoir affichée une erreur précisant la position du caractère à problème, la ligne et le fichier contenant l'erreur
	return (-1);
}


//Teste si la fonction tan reconnue par l'analyseur syntaxique est correcte
int isCorrectTan(char* pc_fileName, int i_line, int i_pos, char* pc_function) {
	if(strlen(pc_function) >= i_pos +4) {
		if (pc_function[i_pos+1]=='a' && pc_function[i_pos+2]=='n'&& pc_function[i_pos+3]=='(' && !isParticularOperatorBinary(pc_function[i_pos+4])) {
			return (4);	
		} else {
			exitErrorSyntax(pc_fileName, pc_function, i_line, i_pos, i_pos+4);
			return (-1);
		}
	}
	exitErrorSyntax(pc_fileName, pc_function, i_line, i_pos, strlen(pc_function));//si il y a une erreur de syntaxe, on quitte le programme après avoir affichée une erreur précisant la position du caractère à problème, la ligne et le fichier contenant l'erreur
	return (-1);
}


//Teste si la fonction de type arc (arccos, arcsin ou arctan) reconnue par l'analyseur syntaxique est correcte
int isCorrectArc(char* pc_fileName, int i_line, int i_pos, char* pc_function) {
	if(strlen(pc_function) >= i_pos +7) {
		if (pc_function[i_pos+1]=='r' && pc_function[i_pos+2]=='c' && pc_function[i_pos+3]=='c' && pc_function[i_pos+4]=='o' && pc_function[i_pos+5]=='s' && pc_function[i_pos+6]=='(' && !isParticularOperatorBinary(pc_function[i_pos+7])) {
			return (7);	
		} else 	if (pc_function[i_pos+1]=='r' && pc_function[i_pos+2]=='c' && pc_function[i_pos+3]=='s' && pc_function[i_pos+4]=='i' && pc_function[i_pos+5]=='n'&& pc_function[i_pos+6]=='(' && !isParticularOperatorBinary(pc_function[i_pos+7])) {
			return (7);	
		} else if (pc_function[i_pos+1]=='r' && pc_function[i_pos+2]=='c' && pc_function[i_pos+3]=='t' && pc_function[i_pos+4]=='a' && pc_function[i_pos+5]=='n'&& pc_function[i_pos+6]=='(' && !isParticularOperatorBinary(pc_function[i_pos+7])) {
			return (7);	
		} else {
			exitErrorSyntax(pc_fileName, pc_function, i_line, i_pos, i_pos+7);
			return (-1);
		}
	}
	exitErrorSyntax(pc_fileName, pc_function, i_line, i_pos, strlen(pc_function));//si il y a une erreur de syntaxe, on quitte le programme après avoir affichée une erreur précisant la position du caractère à problème, la ligne et le fichier contenant l'erreur
	return (-1);
}


//Teste si la fonction hyperbolique reconnue par l'analyseur syntaxique est correcte
int isCorrectHyp(char* pc_fileName, int i_line, int i_pos, char* pc_function) {
	if(strlen(pc_function) >= i_pos +5) {
		if (pc_function[i_pos+1]=='s' && pc_function[i_pos+2]=='i' && pc_function[i_pos+3]=='n' && pc_function[i_pos+4]=='(' && !isParticularOperatorBinary(pc_function[i_pos+5])) {
			return (5);	
		} else 	if (pc_function[i_pos+1]=='c' && pc_function[i_pos+2]=='o' && pc_function[i_pos+3]=='s'&& pc_function[i_pos+4]=='(' && !isParticularOperatorBinary(pc_function[i_pos+5])) {
			return (5);	
		} else if (pc_function[i_pos+1]=='t' && pc_function[i_pos+2]=='a' && pc_function[i_pos+3]=='n'&& pc_function[i_pos+4]=='(' && !isParticularOperatorBinary(pc_function[i_pos+5])) {
			return (5);	
		} else {
			exitErrorSyntax(pc_fileName, pc_function, i_line, i_pos, i_pos+5);
			return (-1);
		}
	}
	exitErrorSyntax(pc_fileName, pc_function, i_line, i_pos, strlen(pc_function));//si il y a une erreur de syntaxe, on quitte le programme après avoir affichée une erreur précisant la position du caractère à problème, la ligne et le fichier contenant l'erreur
	return (-1);
}


//Teste si la l'opérande Pi reconnu par l'analyseur syntaxique est correct
int isCorrectPi(char* pc_fileName, int i_line, int i_pos, char* pc_function) {
	if(strlen(pc_function) >= i_pos +1) {
		if (pc_function[i_pos+1]=='i') {
			return (2);	
		} else {
			exitErrorSyntax(pc_fileName, pc_function, i_line, i_pos, i_pos+1);
			return (-1);
		}
	}
	exitErrorSyntax(pc_fileName, pc_function, i_line, i_pos, strlen(pc_function));//si il y a une erreur de syntaxe, on quitte le programme après avoir affichée une erreur précisant la position du caractère à problème, la ligne et le fichier contenant l'erreur
	return (-1);
}


//Teste si la fonction racine carrée reconnue par l'analyseur syntaxique est correcte
int isCorrectSqrt(char* pc_fileName, int i_line, int i_pos, char* pc_function) {
	if(strlen(pc_function) >= i_pos +5) {
		if (pc_function[i_pos+1]=='q' && pc_function[i_pos+2]=='r' && pc_function[i_pos+3]=='t' && pc_function[i_pos+4]=='(' && !isParticularOperatorBinary(pc_function[i_pos+5])) {
			return (5);	
		} else {
			exitErrorSyntax(pc_fileName, pc_function, i_line, i_pos, i_pos+5);//si il y a une erreur de syntaxe, on quitte le programme après avoir affichée une erreur précisant la position du caractère à problème, la ligne et le fichier contenant l'erreur
			return (-1);
		}
	}
	exitErrorSyntax(pc_fileName, pc_function, i_line, i_pos, strlen(pc_function));//si il y a une erreur de syntaxe, on quitte le programme après avoir affichée une erreur précisant la position du caractère à problème, la ligne et le fichier contenant l'erreur
	return (-1);
}


//Teste si la fonction exponentielle reconnue par l'analyseur syntaxique est correcte
int isCorrectExp(char* pc_fileName, int i_line, int i_pos, char* pc_function) {
	if(strlen(pc_function) >= i_pos +4) {
		if (pc_function[i_pos+1]=='x' && pc_function[i_pos+2]=='p' && pc_function[i_pos+3]=='(' && !isParticularOperatorBinary(pc_function[i_pos+4])) {
			return (4);	
		} else {
			exitErrorSyntax(pc_fileName, pc_function, i_line, i_pos, i_pos+4);//si il y a une erreur de syntaxe, on quitte le programme après avoir affichée une erreur précisant la position du caractère à problème, la ligne et le fichier contenant l'erreur
			return (-1);
		}
	}
	exitErrorSyntax(pc_fileName, pc_function, i_line, i_pos, strlen(pc_function));
	return (-1);
}


//Teste si la parenthèse ouvrante reconnue par l'analyseur syntaxique est correcte
int isCorrectParenthesisOpen(char* pc_fileName, int i_line, int i_pos, char* pc_function) {
	if(i_pos<strlen(pc_function)-1) {
		if(isConstant(pc_function[i_pos+1]) || isOperator(pc_function[i_pos+1]>1)) {
			exitErrorSyntax(pc_fileName, pc_function, i_line, i_pos, i_pos+1);//si il y a une erreur de syntaxe, on quitte le programme après avoir affichée une erreur précisant la position du caractère à problème, la ligne et le fichier contenant l'erreur
			return(-1);
		}
	}
	exitErrorSyntax(pc_fileName, pc_function, i_line, i_pos, i_pos+1);//si il y a une erreur de syntaxe, on quitte le programme après avoir affichée une erreur précisant la position du caractère à problème, la ligne et le fichier contenant l'erreur
	return(-1);
}


//Teste si l'opérande reconnu par l'analyseur syntaxique est correct
int isCorrectOperand(char* pc_fileName, int i_line, int i_pos, char* pc_function) {
	if(i_pos<strlen(pc_function)) {
		if(isConstant(pc_function[i_pos+1]) || isOperator(pc_function[i_pos+1]>1)) {
			exitErrorSyntax(pc_fileName, pc_function, i_line, i_pos, i_pos+1);//si il y a une erreur de syntaxe, on quitte le programme après avoir affichée une erreur précisant la position du caractère à problème, la ligne et le fichier contenant l'erreur
			return(-1);
		}
	}
	return(1);
}



//Teste si un caractère est un opérande prédéfinit 
int isConstant(char c_char) {
	if (c_char=='X'||c_char=='Y'||c_char=='P'||c_char=='R') {
		return (1);//retourne 1 si le caractère est un opérande prédéfinit
	} else {
		return (0);//retourne 0 si le caractère n'est pas un opérande prédéfinit
	}
}


//Teste si un caractère est un opérateur binaire particulier (différent de + ou -)
int isParticularOperatorBinary(char c_char) {
	if (c_char=='*'||c_char=='/'||c_char=='%'|| c_char=='^') {
		return (1);//retourne 1 si le caractère est un opérateur binaire particulier (différent de + ou -)
	} else {
		return (0);//retourne 0 si le caractère n'est pas un opérateur binaire particulier (différent de + ou -)
	}
}


//Teste si un caractère est un opérateur correct
int isCorrectOperator(char* pc_fileName, int i_line, int i_pos,char* pc_function) {
	if(i_pos<strlen(pc_function)-1){
		if(isParticularOperatorBinary(pc_function[i_pos+1])) {//teste si le caractère est un opérateur particulier (différent de + ou -)
			exitErrorSyntax(pc_fileName,pc_function,i_line,i_pos,i_pos+1);
			return(-1);
		} else {
			return(1);
		}
	} else {
		exitErrorSyntax(pc_fileName,pc_function,i_line,i_pos,i_pos+1);
		return(-1);
	}
}


//Teste si un caractère correspond à un opérateur permit ou à une parenthèse
int isAllowOperatorOrParenthesis(char* pc_fileName, int i_line, int i_pos, char* pc_function) {
	switch(pc_function[i_pos]) {
		case '+':
			return(isCorrectOperator(pc_fileName, i_line, i_pos, pc_function));
			break;
		case '-':
			return(isCorrectOperator(pc_fileName, i_line, i_pos, pc_function));
			break;
		case '*':
			return(isCorrectOperator(pc_fileName, i_line, i_pos, pc_function));
			break;
		case '/':
			return(isCorrectOperator(pc_fileName, i_line, i_pos, pc_function));
			break;
		case '%':
			return(isCorrectOperator(pc_fileName, i_line, i_pos, pc_function));
			break;
		case '^':
			return(isCorrectOperator(pc_fileName, i_line, i_pos, pc_function));
			break;
		case '(':
			return(isCorrectOperator(pc_fileName, i_line, i_pos, pc_function));
			break;
		case ')':
			return(1);
			break;
		case '.':
			return(isCorrectOperator(pc_fileName, i_line, i_pos, pc_function));
		default:{
				exitErrorSyntax(pc_fileName,pc_function,i_line,i_pos,i_pos);
				return(-1);
			}
	}
}


//Quitte le programme après avoir affichée un message erreur précisant la position du caractère à problème, la ligne et le fichier contenant l'erreur
void exitErrorSyntax(char* pc_fileName, char* pc_function, int i_line, int i_pos, int i_posMax) {
	char* pc_char;
	int i;
	pc_char=myMalloc(sizeof(char)*(i_posMax-i_pos+1));
	*pc_char='\0';
	for (i = i_pos; i <= i_posMax; i++) {
		sprintf(pc_char, "%s%c", pc_char, pc_function[i]);
	}
	printf("\nErreur de syntaxe \n\n -Fichier : %s\n -Ligne : %s\n -Numéro de ligne :%d\n -Caractères : %s\n -Numéro de caractère : %d - %d\n", pc_fileName, pc_function, i_line, pc_char, i_pos, i_posMax);
	exit(EXIT_FAILURE);
}


//Quitte le programme après avoir affichée un message erreur précisant la ligne et le fichier contenant l'erreur de parenthèses
void exitErrorSyntaxParenthesis(char* pc_fileName, char* pc_function, int i_line) {
	printf("\nErreur de syntaxe \n\n -Fichier : %s\n -Ligne : %s\n -Numéro de ligne :%d\n -Problème lié au parenthèses\n", pc_fileName, pc_function, i_line);
	exit(EXIT_FAILURE);
}


//Quitte le programme après avoir affiché un message d'erreur indiquant le nom du fichier n'existant pas
void exitErrorFileName(char* pc_fileName, char* pc_type) {
	printf("\nErreur : Le fichier %s indiqué n'existe pas.\n\tFichier indiqué : %s\n",pc_type,pc_fileName);
	exit(EXIT_FAILURE);
}


//Quitte le programme après avoir affiché un message d'erreur indiquant le fichier dans lequel le nombre de lignes renseignées est insuffisant
void exitErrorNumberLine(char* pc_fileName) {
	printf("\nErreur : Nombre de lignes renseignées insuffisant\n\tFichier concerné : %s\n",pc_fileName);
	exit(EXIT_FAILURE);
}


//Quitte le programme après avoir affiché un message d'erreur indiquant qu'il y a un problème de syntaxe dans le fichier passé en paramètre
void exitErrorGeneralSyntax(char* pc_fileName) {
	printf("\nErreur de syntaxe dans le fichier L-System\n\tFichier concerné : %s\n",pc_fileName);
	exit(EXIT_FAILURE);
}


//Quitte le programme après avoir affiché un message d'erreur indiquant le symbole concerné par cette erreur
void exitErrorSyntaxSym(char* pc_fileName) {
	printf("\nErreur de syntaxe dans le fichier L-System\n\tFichier concerné : %s\n\tSymboles concernés : '[' ']'\n",pc_fileName);
	exit(EXIT_FAILURE);
}


//Quitte le programme après avoir affiché un message d'erreur indiquant la position du problème
void exitErrorSyntaxLsystem(char* pc_fileName, char* pc_function, int i_line) {
	printf("\nErreur de syntaxe \n\n -Fichier : %s\n -Ligne : %s\n -Numéro de ligne :%d\n ", pc_fileName, pc_function, i_line);
	exit(EXIT_FAILURE);
}


//Teste si un fichier L-System est correct
void testCorrectLsystemFile(char** ppc_tab, int i_nbLine, char* pc_fileName) {
	int i;//entier, variable de boucle
	int i_nbRules;//entier, nombre de règles de la fractale L-System
	int* pi_tabLengthLine;//tableau d'entier indiquant la longueur de chaque ligne
	pi_tabLengthLine=myMalloc(100*sizeof(int));
	if(i_nbLine<5) {
		exitErrorNumberLine(pc_fileName);//Quitte le programme en affichant un message d'erreur
	}
	for (i = 0; i < i_nbLine; i++) {
		pi_tabLengthLine[i]=strlen(ppc_tab[0]);
	}
	if(pi_tabLengthLine[0]%3!=0) {
		exitErrorSyntaxLsystem(pc_fileName, ppc_tab[0], 0);//Quitte le programme en affichant un message d'erreur
	}
	i_nbRules=strlen(ppc_tab[0])/3;
	if(i_nbRules+4>i_nbLine){
		exitErrorNumberLine(pc_fileName);//Quitte le programme en affichant un message d'erreur
	}
}