/*!\file main.h
 *
 * \author SOUPLET Antoine
 * \version 1.0
 * \date 13-01-2012 
 *
 * \brief Fichier contenant les fonctions de recherche d'arguments en ligne de commande, d'affichage de menu ou d'aide, et surtout la fonction main du programme
 *
 */



#include <SDL/SDL.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <time.h>
#include <string.h>
#include "lSystem.h"
#include "drawFractal.h"
#include "functionSdl.h"
#include "drawGeo.h"
#include "main.h"
#include "thread.h"
#include <pthread.h>
#include "functionAdd.h"


//Fonction main du programme
int main(int argc, char** argv) {
	int i_width;//Entier représentant la largeur de l'écran
	int i_height;//Entier représentant la hauteur de l'écran
	int i_fractalNumber;//Entier correspondant au numéro de la fractale à dessiner
	double* pd_zoom;//Un pointeur vers un double représentant le zoom
	pd_zoom=myMalloc(sizeof(double*));
	i_width = searchArgW(argc,argv);//Recherche un argument correspondant à la largeur de l'écran
	i_height =searchArgH(argc,argv);//Recherche un argument correspondant à la hauter de l'écran
	i_fractalNumber =searchFractal(argc, argv);//Recherche un argument correspondant au dessin d'une fractale
	*pd_zoom =searchZoom(argc, argv);//Recherche un argument correspondant au zoom
	SDL_Init(SDL_INIT_VIDEO);//Initialise la SDL
	drawFractal(argc, argv,i_width, i_height, pd_zoom, i_fractalNumber);
	SDL_Quit();
	printf("Fin du programme\n");
	return (0);
}


//Fonction recherchant un argument correspondant à la largeur de l'écran
int searchArgW(int argc, char** argv) {
	int i;//variable de boucle
	for(i=0;i<(argc-1);i++) {
		if(!strcmp(argv[i], "-w")) {
			return strtol(argv[i+1], (char **)NULL, 10);
		}
	}
	return (1000);//Retourne une largeur d'écran par défaut
}


//Fonction recherchant un argument correspondant à la hauteur de l'écran
int searchArgH(int argc, char** argv) {
	int i;//variable de boucle
	for(i=0;i<(argc-1);i++) {
		if(!strcmp(argv[i], "-h")) {
			return strtol(argv[i+1], (char **)NULL, 10);
		}
	}
	return (600);//Retourne une hauteur d'écran par défaut
}


//Fonction recherchant le numéro de fractale correspondant à l'agument de dessin de fractale rentrée en paramètre
int searchFractal(int argc, char** argv) {
	int i;//variable de boucle
	for(i=0; i<argc; i++) {
		if(!strcmp(argv[i], "-m")) {
			return (1);
		}
		else if(!strcmp(argv[i], "-j")) {
			return (2);
		}
		else if(!strcmp(argv[i], "-jj")) {
			return (3);
		}
		else if(!strcmp(argv[i], "-l")) {
			return (4);
		}
		else if(!strcmp(argv[i], "-i")) {
			return (5);
		}
		else if(!strcmp(argv[i],"-f")) {
			return (6);
		}
		else if(!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")){
			return (7);
		}
	}
	printf("Aucun argument d'execution ne correspond au dessin d'une fractale\n");
	return (displayMenu());	//Dans le cas ou aucun n'argument de dessin n'a été saisit, on affiche un menu		
}


//Fonction recherchant le zoom dans les arguments saisis par l'utilisateur
double searchZoom(int argc, char** argv) {
	int i;//variable de boucle
	for(i=0; i<(argc-1); i++) {
		if(!strcmp(argv[i],"-z")) {
			return (strtol(argv[i+1], (char **)NULL, 10));
		}
	}
	return (1.0);//retourne une valeur du zoom par défaut
}


//Fonction recherchant le fichier dans les arguments saisis par l'utilisateur
char* searchFileOfFlame(int argc, char** argv) {
	int i;//variable de boucle
	for(i=0; i<(argc-1); i++) {
		if(!strcmp(argv[i], "-ff")) {
			return (argv[i+1]);
		}
	}
	return (displayFlameChoice());//affiche les différentes flammes
}


//Fonction recherchant le fichier Ifs dans les arguments saisis par l'utilisateur
char* searchFileOfIFS(int argc, char** argv) {
	int i;//variable de boucle
	for(i=0; i<(argc-1); i++) {
		if(!strcmp(argv[i], "-if")) {
			return (argv[i+1]);
		}
	}
	return ("./files_config/ifs/dragon.ifs");//retourne une fichier Ifs par défaut
}


//Fonction recherchant le fichier L-System dans les arguments saisis par l'utilisateur
char* searchFileOfLSystem(int argc, char** argv) {
	int i;//variable de boucle
	for(i=0; i<(argc-1); i++){
		if(!strcmp(argv[i], "-li")) {
			return (argv[i+1]);
		}
	}
	return ("./files_config/lsystem/tree1.lsystem");//retourne un fichier L-System par défaut
}





//Fonction lancant les traitements des différentes fractales
void drawFractal(int argc, char** argv, int i_width, int i_height, double *pd_zoom, int i_fractalNumber) {
	switch (i_fractalNumber) {
		case 1:
			launchMandelbrot(i_width, i_height, pd_zoom, isFullScreen(argc, argv));
			break;
		case 2:
			launchJulia(searchPointCoeffJulia(argc, argv), i_width, i_height, pd_zoom, isFullScreen(argc, argv));
			break;
		case 3:
			launchJulia2(searchPointCoeffJulia(argc, argv), i_width, i_height, pd_zoom, isFullScreen(argc, argv));
			break;
		case 4:
			launchLsystem(i_width, i_height, pd_zoom, argc, argv, isFullScreen(argc, argv));
			break;
		case 5:
			launchIfs(i_width, i_height, pd_zoom, argc, argv, isFullScreen(argc, argv));
			break;
		case 6:
			launchFlame(i_width, i_height, pd_zoom, argc, argv, isFullScreen(argc, argv));
			break;
		case 7:
			displayHelp();//Affiche l'aide
			break;
		default:{}
	}
}


//Fonction lançant le traitement de la fractale de mandelbrot
void launchMandelbrot(int i_width, int i_height, double* pd_zoom, int i_fullScreen) {
	SDL_Surface* surf_screen;//Pointeur vers l'écran sur lequel on dessine la fractale de Mandelbrot
	Point* ppoint_mandelbrot;//Pointeur vers un point représentant le point initial de Mandelbrot
	const SDL_VideoInfo* vidi_videoInfo;//Informations concernant la gestion vidéo de l'ordinateur lançant le programme
	int* pi_numGradient;//Pointeur vers un entier représentant le numéro de coloration de la fractale de Mandelbrot
	int* pi_nbIter;//Pointeur vers une entier représentant le nombre d'itérations
	vidi_videoInfo = SDL_GetVideoInfo();
	ppoint_mandelbrot=pointInitAndSet(0.5,0.0);
	pi_nbIter=myMalloc(sizeof(int));
	pi_numGradient=myMalloc(sizeof(int));
	*pi_numGradient=2;
	*pi_nbIter=256;
	if(i_fullScreen) {
		surf_screen=SDL_SetVideoMode(vidi_videoInfo->current_w, vidi_videoInfo->current_h, 32, SDL_HWSURFACE|SDL_DOUBLEBUF|SDL_FULLSCREEN );
	} else {
		surf_screen=SDL_SetVideoMode(i_width, i_height, 32, SDL_HWSURFACE|SDL_DOUBLEBUF  );
	}
	drawFractalM(surf_screen,pd_zoom, ppoint_mandelbrot, pi_nbIter, pi_numGradient);//Dessine la fractale de Mandelbrot
	waitEventMandelbrot(surf_screen,pd_zoom,ppoint_mandelbrot, pi_nbIter, pi_numGradient);//Attends un évènement
}


//Fonction lançant le traitement de la fractale de Julia
void launchJulia(Point* ppoint_coeffC, int i_width, int i_height, double *pd_zoom, int i_fullScreen) {
	SDL_Surface* surf_screen;//Pointeur vers l'écran sur lequel on dessine la fractale de Julia
	Point* ppoint_julia;//Pointeur vers un point représentant le point initial de Julia
	const SDL_VideoInfo* vidi_videoInfo;//Informations concernant la gestion vidéo de l'ordinateur lançant le programme
	int* pi_numGradient;//Pointeur vers un entier représentant le numéro de coloration de la fractale Mandelbrot
	int* pi_nbIter;//Pointeur vers un entier représentant le nombre d'itérations
int* pi_reverse;
	vidi_videoInfo = SDL_GetVideoInfo();
	ppoint_julia=pointInitAndSet(0.0,0.0);
	pi_nbIter=myMalloc(sizeof(int));
	pi_numGradient=myMalloc(sizeof(int));
	pi_reverse=myMalloc(sizeof(int));
*pi_reverse=0;
	*pi_numGradient=2;
	*pi_nbIter=256;
	if(i_fullScreen) {
		surf_screen=SDL_SetVideoMode(vidi_videoInfo->current_w, vidi_videoInfo->current_h, 32, SDL_HWSURFACE|SDL_DOUBLEBUF|SDL_FULLSCREEN );
	} else {
		surf_screen=SDL_SetVideoMode(i_width, i_height, 32, SDL_HWSURFACE|SDL_DOUBLEBUF  );
	}
	drawFractalJ(surf_screen,pd_zoom,ppoint_julia, ppoint_coeffC, pi_nbIter, pi_numGradient, pi_reverse);//Dessine la fractale de Julia
	waitEventJulia(surf_screen,pd_zoom, ppoint_julia, ppoint_coeffC, pi_nbIter, pi_numGradient,pi_reverse);//Attends un évènement
}


//Fonction lançant le traitement de la fractale de Julia en temps réel
void launchJulia2(Point* ppoint_coeffC, int i_width, int i_height, double *pd_zoom, int i_fullScreen) {
	SDL_Surface* surf_screen;//Pointeur vers l'écran sur lequel on dessine la fractale de Julia en temps réel
	Point*ppoint_julia;//Pointeur vers un point représentant le point initial de Julia
	const SDL_VideoInfo* vidi_videoInfo;//Informations concernant la gestion vidéo de l'ordinateur lançant le programme
	int* pi_nbIter;//Pointeur vers un entier représentant le nombre d'itérations
	int* pi_numGradient;//Pointeur vers un entier représentant le numéro de coloration
int * pi_reverse;
	pi_reverse=myMalloc(sizeof(int));
*pi_reverse=0;
	pi_nbIter=myMalloc(sizeof(int));
	pi_numGradient=myMalloc(sizeof(int));
	*pi_numGradient=3;
	*pi_nbIter=256;
	vidi_videoInfo = SDL_GetVideoInfo();
	ppoint_julia=pointInitAndSet(0.0,0.0);
	if(i_fullScreen) {
		surf_screen=SDL_SetVideoMode(vidi_videoInfo->current_w, vidi_videoInfo->current_h, 32, SDL_HWSURFACE|SDL_DOUBLEBUF|SDL_FULLSCREEN );
	} else {
		surf_screen=SDL_SetVideoMode(i_width, i_height, 32, SDL_HWSURFACE|SDL_DOUBLEBUF  );
	}
	drawFractalJ(surf_screen,pd_zoom,ppoint_julia, ppoint_coeffC, pi_nbIter, pi_numGradient,pi_reverse);//Dessine la fractale de Julia
	waitEventJulia2(surf_screen,pd_zoom, ppoint_julia, ppoint_coeffC, pi_nbIter, pi_numGradient,pi_reverse);//Attends un évènement
}


//Fonction lançant le traitement des fractales de type L-System
void launchLsystem(int i_width, int i_height, double *pd_zoom, int argc, char** argv, int i_fullScreen) {
	Lsystem* lsyst_lSystem;//Pointeur vers une structure de type L-System
	SDL_Surface* surf_screen;//Pointeur vers l'écran sur lequel on dessine la fractale de type L-System
	Point* ppoint_lSystem;//Pointeur vers un point représentant le point initial de la fractale L-System
	int* pi_indice;//Pointeur vers un entier représentant l'indice auquel il faut dessiner la fractale L-System
	const SDL_VideoInfo* vidi_videoInfo;//Informations concernant la gestion vidéo de l'ordinateur lançant le programme
	vidi_videoInfo = SDL_GetVideoInfo();
	pi_indice=myMalloc(sizeof(int*));
	*pi_indice=1;
	ppoint_lSystem=pointInitAndSet(200.0,400.0);
	if(i_fullScreen) {
		surf_screen=SDL_SetVideoMode(vidi_videoInfo->current_w, vidi_videoInfo->current_h, 32, SDL_HWSURFACE|SDL_DOUBLEBUF|SDL_FULLSCREEN );
	} else {
		surf_screen=SDL_SetVideoMode(i_width, i_height, 32, SDL_HWSURFACE|SDL_DOUBLEBUF  );
	}
	lsyst_lSystem = initLsystem(surf_screen, pd_zoom, ppoint_lSystem, searchFileOfLSystem(argc, argv),pi_indice);
	runLsystem(lsyst_lSystem);
}


//Fonction lançant le traitement des fractales de type Ifs
void launchIfs(int i_width, int i_height, double *pd_zoom, int argc, char** argv, int i_fullScreen) {
	SDL_Surface* surf_screen;//pointeur vers l'écran sur lequel on dessine la fractale Ifs
	Ifs* ifs_ifs;//pointeur vers une structure de type Ifs
	Point* ppoint_ifs;//pointeur vers le point initial de la fractale Ifs
	Point* ppoint_pitch;//pointeur vers le point permettant de décaler la fractale Ifs
	const SDL_VideoInfo* vidi_videoInfo;//Informations concernant la gestion vidéo de l'ordinateur lançant le programme
	vidi_videoInfo = SDL_GetVideoInfo();
	if(i_fullScreen) {
		surf_screen=SDL_SetVideoMode(vidi_videoInfo->current_w, vidi_videoInfo->current_h, 32, SDL_HWSURFACE|SDL_DOUBLEBUF|SDL_FULLSCREEN );
	} else {
		surf_screen=SDL_SetVideoMode(i_width, i_height, 32, SDL_HWSURFACE|SDL_DOUBLEBUF  );
	}
	ppoint_pitch=pointInitAndSet(0.0,-170.0);
	ppoint_ifs=pointInitAndSet(0.5,0.7);
	ifs_ifs=initIfs(surf_screen, ppoint_ifs, ppoint_pitch, searchFileOfIFS(argc, argv), pd_zoom, 1000000);
	drawFractalIfs(ifs_ifs);//dessine la fractale Ifs
	waitEventIFS(ifs_ifs);//attends un évènement
}


//Fonction lançant le traitement des fractales de type Flamme
void launchFlame(int i_width, int i_height, double *pd_zoom, int argc, char** argv, int i_fullScreen) {
	Flame* flame_flame;//pointeur vers une structure Flamme
	Point* ppoint_flame;//pointeur vers un point représentant le point initial de la fractale Flamme
	Point* ppoint_pitch;//pointeur vers le point permettant de décaler la fractale Flamme
	SDL_Surface *surf_screen;//pointeur vers l'écran sur lequel on dessine la fractale Flamme
	char* pc_fileName;//chaine de caractère représentant le nom du fichier Flamme
	const SDL_VideoInfo* vidi_videoInfo;//informations concernant la gestion vidéo de l'ordinateur lançant le programme
	vidi_videoInfo = SDL_GetVideoInfo();
	pc_fileName=searchFileOfFlame(argc, argv);
	if(i_fullScreen) {
		surf_screen=SDL_SetVideoMode(vidi_videoInfo->current_w, vidi_videoInfo->current_h, 32, SDL_HWSURFACE|SDL_DOUBLEBUF|SDL_FULLSCREEN );
	} else {
		surf_screen=SDL_SetVideoMode(i_width, i_height, 32, SDL_HWSURFACE|SDL_DOUBLEBUF  );
	}
	ppoint_flame=pointInitAndSet(0.5,0.7);
	ppoint_pitch=pointInitAndSet(00,-100);
	flame_flame= initFlame(surf_screen, ppoint_flame, ppoint_pitch,pc_fileName , pd_zoom, 1000000);
	drawFractalFlame(flame_flame);//dessine la fractale Flamme
	waitEventFlame(flame_flame);//attends un évènement
}

void showMenu() {
	printf("\n\n --------------------------------------------\n");
	printf("|               Programme Fractale           |\n");
	printf(" -------------------------------------------- \n\n");
	printf("\t1. Fractale de Mandelbrot\n");
	printf("\t2. Fractale de Julia\n");
	printf("\t3. Fractale de Julia (mise à jour en temps réél)\n");
	printf("\t4. Fractale L-system\n");
	printf("\t5. Fractale Ifs\n");
	printf("\t6. Fractale Flame\n\n");
	printf("\t7. Aide\n");
	printf("\t8. Quitter le programme\n\n");
	printf("\t=> ");
}


//Fonction affichant le menu
int displayMenu() {
	char c_temp;//Un caractère correspondant au choix de l'utilisateur
	int i_res;//Un entier correspondant à la valeur à retourner en fonction du choix de l'utilisateur
	showMenu();
	scanf("%c", &c_temp);
	while(!isIntegerBetween(c_temp,1,8) || isIntegerBetween(c_temp,7,7)) {
		if(isIntegerBetween(c_temp,7,7)) {
			displayHelp();
			showMenu();
		}
		scanf("%c", &c_temp);
	}
	i_res=c_temp-'0';
	return (i_res);
}


//Fonction recherchant les coefficients de Julia dans les arguments saisis par l'utilisateur
Point* searchPointCoeffJulia(int argc,char** argv){
	int i;//variable de boucle
	double d_jRe;//réel correspondant à la partie réelle du coefficient de Julia
	double d_jIm;//réel correspond à la partie imaginaire du coefficient de Julia
	Point *ppoint_coeffC;//pointeur vers un point représentant les coefficients de Julia
	d_jRe=0.382;
	d_jIm=0.147;
	for(i=0; i<(argc-1); i++) {
		if(!strcmp(argv[i], "-jre")) {
			d_jRe=atof(argv[i+1]);
			i++;
		}
		else if(!strcmp(argv[i], "-jim")) {
			d_jIm=atof(argv[i+1]);
			i++;
		}
	}
	ppoint_coeffC=pointInitAndSet(d_jRe,d_jIm);
	return (ppoint_coeffC);//retourne un point représentant les coefficients de Julia
}


//Fonction recherchant l'argument indiquant si le lancement doit être effectué en fullscreen, retourne 1 si on lance le fichier en fullScreen
int isFullScreen(int argc, char** argv) {
	int i;//variable de boucle
	for(i=0; i<argc; i++) {
		if(!strcmp(argv[i], "--full")) {
			return (1);
		}
	}
	return (0);
}


//Fonction affichant l'aide
void displayHelp() {
	printf("                             -->  Aide <--\n");
	printf("\n\n\nPour executer le programme de dessin de fractales entrer la commande: ./bin/Fractal.exe [options]\n\n\n");
	printf("   Liste des options:\n\n");
	printf("    ->Afficher l'aide\n");
	printf("        -h          Pour afficher la page d'aide\n");
	printf("        --help      Pour afficher la page d'aide\n\n");
	printf("    ->Types de fractales\n");
	printf("        -m          Pour dessiner une fractale de Mandelbrot\n");
	printf("        -j          Pour dessiner une fractale de Julia\n");
	printf("        -jj         Pour dessiner une fractale de Julia avec mise à jour en temps réél\n");
	printf("        -l          Pour dessiner une fractale L-System\n");
	printf("        -i          Pour dessiner une fractale IFS\n");
	printf("        -f          Pour dessiner une fractale Flamme\n\n");
	printf("    ->Paramètres d'affichage\n");
	printf("        -w width    Pour définir la largeur de la fenêtre (où width est la largeur en pixels)\n");
	printf("        -h height   Pour définir la hauteur de la fenêtre (où height est la hauteur en pixels)\n");
	printf("        --full      Pour afficher la fenêtre en mode plein-écran\n");
	printf("        -z zoom     Pour définir la valeur du zoom initial (où zoom est la valeur du zoom)\n\n");
	printf("    ->Paramètres Julia\n");
	printf("        -jre real   Pour définir la valeur de la partie réelle de la constante de Julia (où real est la valeur de Re(c))\n");
	printf("        -jim img    Pour définir la valeur de la partie imaginaire de la constante de Julia (où img est la valeur de Im(c))\n\n");
	printf("    ->Gestion de fichier\n");
	printf("        -li path    Pour préciser un fichier de définition d'une fractale L-System\n");
	printf("        -if path    Pour préciser un fichier de définition d'une fractale IFS\n");
	printf("        -ff path    Pour préciser un fichier de défintion d'une fractale Flamme\n");
	printf("                    Des exemples de fichier de définition sont présent dans ./files_config/\n\n");
	printf("    exemples:  ./Fractal.exe -j -jre 0.358 -jim -0.454 -w 1024 -h 768\n");
	printf("               ./Fractal.exe -f -ff ./files_config/v9.flame -z 2\n");
}

void showFlame() {
	printf("\t~~~ Choix fractale Flamme ~~~\n\n");
	printf("\t0. Linear \n");
	printf("\t1. Sinusoidal\n");
	printf("\t2. Spherical\n");
	printf("\t3. Swirl\n");
	printf("\t4. Horseshoe\n");
	printf("\t5. Polar\n");
	printf("\t6. Handkerchief\n");
	printf("\t7. Heart\n");
	printf("\t8. Disk\n");
	printf("\t9. Spiral\n");
	printf("\t10. Hyperbolic\n");
	printf("\t11. Diamond\n");
	printf("\t12. Ex\n");
	printf("\t13. Julia\n");
	printf("\t14. Bent\n");
	printf("\t15. Waves\n");
	printf("\t16. Fisheye\n");
	printf("\t17. Popcorn\n");
	printf("\t18. Exponential\n");
	printf("\t19. Power\n");
	printf("\t20. Cosine\n");
	printf("\t21. Eyefish\n");
	printf("\t22. Bubble\n");
	printf("\t23. Cylinder\n");
	printf("\t24. Tangent\n\t25. Cross\n");
	printf("\t=> ");
}

//Fonction affichants différentes fractales flammes et proposant le choix à l'utilisateur
char* displayFlameChoice() {
	char* pc_tempFlame;//variable représentant le nom de la fractale flamme à dessiner
	char* pc_tempIfs;//chaine de caractère représentant le nom de la fractale Ifs à associer à flamme
	char* pc_choices;//chaine de caractère représentant le choix de l'utilisateur
	pc_tempFlame=myMalloc(sizeof(char)*200);
	pc_tempIfs=myMalloc(sizeof(char)*200);
	pc_choices=myMalloc(sizeof(char)*500);
	showFlame();
	scanf("%s", pc_tempFlame);
	while(!isCorrectFlameNumber(pc_tempFlame)) {
		scanf("%s", pc_tempFlame);
	}
	printf("~~~ Choix fractale Ifs ~~~\n\n");
	printf("\t1. Fern\n");
	printf("\t2. Spiral\n");
	printf("\t3. Dragon\n");
	printf("\t4. Coral\n");
	printf("\t5. Triangle\n");
	printf("\t6. Floor\n");
	printf("\t7. Binary\n");
	printf("\t8. Koch\n");
	printf("\t9. Tree\n");
	printf("\t10. Fractint\n");
	printf("\t11. Zigzag\n");
	printf("\t=> ");
	scanf("%s", pc_tempIfs);
	while(!isCorrectIfsNumber(pc_tempIfs)) {
		scanf("%s", pc_tempIfs);
	}
	sprintf(pc_choices, "%s%s%c%s","choice|",pc_tempFlame,'/',pc_tempIfs);
	return (pc_choices);
}


int isCorrectFlameNumber(char* pc_flameNumber) {
	if(strlen(pc_flameNumber)==1) {
		return(isIntegerBetween(pc_flameNumber[0],0,9));
	}
	else if(strlen(pc_flameNumber)==2) {
		if(isIntegerBetween(pc_flameNumber[1], 0, 9) && isIntegerBetween(pc_flameNumber[0], 0, 2)) {
			return(1);
		}
	}
	printf("Saisie incorrecte\n");
	return (0);
}


int isCorrectIfsNumber(char* pc_ifsNumber) {
	if(strlen(pc_ifsNumber)==1) {
		return(isIntegerBetween(pc_ifsNumber[0],1,9));
	}
	else if(strlen(pc_ifsNumber)==2) {
		if(isIntegerBetween(pc_ifsNumber[1], 0, 1) && isIntegerBetween(pc_ifsNumber[0], 0, 1)) {
			return(1);
		}
	}
	printf("Saisie incorrecte\n");
	return (0);
}