/*!\file ifs.c
 *
 * \author LEDIT Alexandre & SOUPLET Antoine
 * \version 1.0
 * \date 12-01-2012 
 *
 * \brief Fichier contenant toutes les fonctions associées aux fractales de type Ifs
 *
 */

#include "functionAdd.h"
#include "ifs.h"
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include "functionSdl.h"
#include "postfix.h"
#include <SDL/SDL.h>


//Fonction initialisant la structure Ifs, alloue la mémoire nécéssaire à la structure et initialise ses attributs
Ifs* initIfs(SDL_Surface* surf_screen, Point* ppoint_pInit, Point* ppoint_pitch, char* pc_fileName, double* pd_zoom, int i_nbPoint){
Ifs *ifs_ifs;//pointeur vers une structure correspondant à la fractale Ifs
ifs_ifs=myMalloc(sizeof(Ifs));//alloue la mémoire nécéssaire à la structure Ifs
(*ifs_ifs).surf_screen=surf_screen;
(*ifs_ifs).pd_zoom = pd_zoom;
(*ifs_ifs).ppoint_pInit=ppoint_pInit;
(*ifs_ifs).ppoint_pitch=ppoint_pitch;
(*ifs_ifs).pc_fileName=pc_fileName;
(*ifs_ifs).i_nbPoint=i_nbPoint;
(*ifs_ifs).i_maxColor=0;
createTabColorIfs(ifs_ifs);
(*ifs_ifs).pd_color=myMalloc(sizeof(double)*3);
ifs_ifs->i_lockScreen=0;
ifs_ifs->d_light=0.6;
ifs_ifs->i_functionMode=1;
ifs_ifs->i_currentColor=0;
ifs_ifs->ppi_coloration=initColoration();
return (ifs_ifs);
}


//Fonction libérant la mémoire allouée à la structure Ifs et à ses attributs
void freeIfs(Ifs* ifs_ifs) {
int i;//variable de boucle
for (i = 0; i < ifs_ifs->surf_screen->w; i++) {
free(ifs_ifs->ppi_tabColor[i]);
}
free(ifs_ifs->ppi_tabColor);
SDL_FreeSurface(ifs_ifs->surf_screen);
free(ifs_ifs->pd_zoom);
free(ifs_ifs->ppoint_pInit);
free(ifs_ifs->ppoint_pitch);
free(ifs_ifs);
}


//Initialise la coloration pour Ifs et Flamme
int** initColoration() {
	int i;//variable de boucle
	int ** ppi_coloration;//tableau deux dimensions de couleurs
	ppi_coloration=myMalloc(sizeof(int*)*100);
	for (i = 0; i < 50; i++) {
		ppi_coloration[i]=myMalloc(2*sizeof(int*)*20);
	}
	beginColoration(ppi_coloration);
	endColoration(ppi_coloration);
	ppi_coloration[8][0]=2;
	ppi_coloration[8][1]=1;
	ppi_coloration[8][2]=0;
	ppi_coloration[8][3]=1;
	ppi_coloration[8][4]=1;
	ppi_coloration[8][5]=1;
	return(ppi_coloration);
}


//Initialise la coloration Ifs et Flamme en association avec endColoration et initColoration
void beginColoration(int **ppi_coloration) {
	ppi_coloration[0][0]=2;
	ppi_coloration[0][1]=1;
	ppi_coloration[0][2]=1;
	ppi_coloration[0][3]=1;
	ppi_coloration[0][4]=1;
	ppi_coloration[0][5]=1;
	ppi_coloration[1][0]=0;
	ppi_coloration[1][1]=1;
	ppi_coloration[1][2]=2;
	ppi_coloration[1][3]=1;
	ppi_coloration[1][4]=0;
	ppi_coloration[1][5]=1;
	ppi_coloration[2][0]=1;
	ppi_coloration[2][1]=0;
	ppi_coloration[2][2]=1;
	ppi_coloration[2][3]=1;
	ppi_coloration[2][4]=1;
	ppi_coloration[2][5]=0;
	ppi_coloration[3][0]=0;
	ppi_coloration[3][1]=2;
	ppi_coloration[3][2]=1;
	ppi_coloration[3][3]=1;
	ppi_coloration[3][4]=1;
	ppi_coloration[3][5]=1;
}


//Initialise la coloration Ifs et Flamme en association avec beginColoration et initColoration
void endColoration(int **ppi_coloration) {
	ppi_coloration[4][0]=1;
	ppi_coloration[4][1]=0;
	ppi_coloration[4][2]=2;
	ppi_coloration[4][3]=0;
	ppi_coloration[4][4]=1;
	ppi_coloration[4][5]=1;
	ppi_coloration[5][0]=1;
	ppi_coloration[5][1]=0;
	ppi_coloration[5][2]=2;
	ppi_coloration[5][3]=1;
	ppi_coloration[5][4]=1;
	ppi_coloration[5][5]=1;
	ppi_coloration[6][0]=1;
	ppi_coloration[6][1]=0;
	ppi_coloration[6][2]=0;
	ppi_coloration[6][3]=1;
	ppi_coloration[6][4]=1;
	ppi_coloration[6][5]=0;
	ppi_coloration[7][0]=2;
	ppi_coloration[7][1]=1;
	ppi_coloration[7][2]=0;
	ppi_coloration[7][3]=1;
	ppi_coloration[7][4]=0;
	ppi_coloration[7][5]=1;
}


//Alloue la mémoire nécéssaire au tableau de couleurs Ifs
void createTabColorIfs(Ifs* ifs_ifs) {
	int i;//variable de boucle
	int j;//variable de boucle
	ifs_ifs->ppi_tabColor=myMalloc(sizeof(int*)*(ifs_ifs->surf_screen->w));
	for (i = 0; i < ifs_ifs->surf_screen->w; i++) {
		ifs_ifs->ppi_tabColor[i]=myMalloc(2*sizeof(int*)*(ifs_ifs->surf_screen->h));
		for (j = 0; j < ifs_ifs->surf_screen->h*2+2; j++) {
			ifs_ifs->ppi_tabColor[i][j]=0;
		}
	}
}


//Calcule la couleur Ifs en fonction des paramètres tels que l'intensité lumineuse
void computingColor(double* pd_color, int** ppi_tabColor, int i_maxColor, SDL_Rect rect_position, double d_light, int i_functionMode, int** ppi_coloration, int i_currentColor) {
	pd_color[0]=0;
	pd_color[1]=0;
	pd_color[2]=0;
	if (i_functionMode) {
		pd_color[ppi_coloration[i_currentColor][0]]=pd_color[0]*(1-d_light)+d_light*(255-30*(ppi_tabColor[rect_position.x][2*rect_position.y+1]));
		pd_color[ppi_coloration[i_currentColor][1]]=pd_color[1]*(1-d_light)+d_light*(255-30*(ppi_tabColor[rect_position.x][2*rect_position.y+1]));
		pd_color[ppi_coloration[i_currentColor][2]]=pd_color[2]*(1-d_light)+d_light*(0+30*(ppi_tabColor[rect_position.x][2*rect_position.y+1]));

	} else	if(i_currentColor && i_currentColor%2==0) {
		pd_color[i_currentColor/4]=pd_color[i_currentColor/4]*(1-d_light)+d_light*(255);
	}
	else {
		pd_color[ppi_coloration[i_currentColor][0]]=pd_color[0]*(1-d_light)+d_light*(255);
		pd_color[ppi_coloration[i_currentColor][1]]=pd_color[1]*(1-d_light)+d_light*(255);
		pd_color[ppi_coloration[i_currentColor][2]]=pd_color[2]*(1-d_light)+d_light*(255);
	}
	pd_color[0]=((pd_color[0])*ppi_coloration[i_currentColor][3]*(log(ppi_tabColor[rect_position.x][2*rect_position.y]+1)/log(i_maxColor+1)));
	pd_color[1]=((pd_color[1])*ppi_coloration[i_currentColor][4]*(log(ppi_tabColor[rect_position.x][2*rect_position.y]+1)/log(i_maxColor+1)));
	pd_color[2]=((pd_color[2])*ppi_coloration[i_currentColor][5]*(log(ppi_tabColor[rect_position.x][2*rect_position.y]+1)/log(i_maxColor+1)));
}




//Calcule le nouveau point Ifs
SDL_Rect computingNewPointIfs(Ifs *ifs_ifs, double* pd_tabCoef){
	double d_X;//réel correspondant à l'abscisse du point Ifs calculé
	double d_Y;//réel correspond à l'ordonnée du point Ifs calculé
	SDL_Rect rect_position;//Rectangle correspondant à la position du point à retourner et à dessiner
	d_Y=(pd_tabCoef[2]*ifs_ifs->ppoint_pInit->x+pd_tabCoef[3]*ifs_ifs->ppoint_pInit->y+pd_tabCoef[5]);
	d_X=(pd_tabCoef[0]*ifs_ifs->ppoint_pInit->x+pd_tabCoef[1]*ifs_ifs->ppoint_pInit->y+pd_tabCoef[4]);
	rect_position.x=d_X*40*(*(ifs_ifs->pd_zoom))+(ifs_ifs->surf_screen->w)/2+((*(ifs_ifs->ppoint_pitch)).x)*(*(ifs_ifs->pd_zoom));
	rect_position.y=d_Y*40*(*(ifs_ifs->pd_zoom))+(ifs_ifs->surf_screen->h)/2+((*(ifs_ifs->ppoint_pitch)).y)*(*(ifs_ifs->pd_zoom));
	ifs_ifs->ppoint_pInit->x=d_X;	
	ifs_ifs->ppoint_pInit->y=d_Y;
	return(rect_position);//retourne la position du point à dessiner
}


//Fonction qui récupère le tableau de probabilités, où chaque case contient la somme des premières probabilités
double* getTabProba(double** ppd_tabCoef, int i_nbOfLine) {
	double* pd_tabProba;//pointeur vers un double représentant un tableau de probabilité
	int i;//variable de boucle
	double d_sum;//réel représentant la somme des probabilités
	pd_tabProba=myMalloc(sizeof(double)*(i_nbOfLine+1));
	d_sum=0.0;
	for (i = 0; i < (i_nbOfLine+1); i++) {
		d_sum=d_sum+ppd_tabCoef[i][6];
		pd_tabProba[i]=100-d_sum*100;
	}
	if(d_sum<1){
	  printf("La somme des probabilités d'appel de fonction IFS, n'est pas égale à 1\n");
	  exit(0);
	}
	return(pd_tabProba);//retourne le tableau de probabilités
}


//récupère une tableau de coefficient depuis un fichier
double** getCoeffTabFromFile(char* pc_filePath) {
	FILE* fi_functionsDef;//Pointeur vers un fichier
	int i_numberOfLine;//entier représentant le nombre de ligne
	double** ppd_tabCoeff;//tableau de réel correpondant aux coefficients à extraire du fichier Ifs
	int i_nbCoeff;//entier représentant le nombre de coefficient
	int i;//variable de boucle
	int j;//variable de boucle
	i_numberOfLine=numberOfLine(pc_filePath);
	ppd_tabCoeff=myMalloc(sizeof(double*)*(i_numberOfLine+1));
	i_nbCoeff=7;
	fi_functionsDef=fopen(pc_filePath, "r");
	for (i = 0; i < (i_numberOfLine+1); i++) {
		ppd_tabCoeff[i]=myMalloc(sizeof(double)*i_nbCoeff);
		for (j = 0; j < i_nbCoeff; j++) {
		  if(j==i_nbCoeff-1){
		    if(!fscanf(fi_functionsDef, "%lf;", &ppd_tabCoeff[i][j])){
		      printf("Le nombre de coefficient de la ligne %d du fichier %s est incorrect\n", i+1, pc_filePath);
		      exit(0);
		    }
		  }else if(!fscanf(fi_functionsDef, "%lf ", &ppd_tabCoeff[i][j])){
		    printf("Erreur de syntaxe dans le fichier %s", pc_filePath);
		    exit(0);
		  }
		}
	}
	fclose(fi_functionsDef);
	return(ppd_tabCoeff);
}




//Rempli le tableau e couleurs Ifs
void fillTabColorIfs(Ifs* ifs_ifs,double* pd_tabProba, double** ppd_tabCoeff) {
	int i;//variable de boucle
int i_aleat;//entier permettant de choisir la fonction Ifs en fonction du tableau de probabilité
	int i_functionNumber;//entier représentant la fonction Ifs
	SDL_Rect rect_position;//rectangle correspondant à la position du pixel à dessiner
	for (i = 21; i < ifs_ifs->i_nbPoint; ++i) {
		i_aleat=rand()%100;
		i_functionNumber=0;
		while(i_aleat<pd_tabProba[i_functionNumber]) { 
			i_functionNumber++;
		}
		rect_position=computingNewPointIfs(ifs_ifs, ppd_tabCoeff[i_functionNumber]);//calcule le nouveau point Ifs à dessiner
		if (rect_position.y>=0&& rect_position.x>=0&& rect_position.x<ifs_ifs->surf_screen->w && rect_position.y<ifs_ifs->surf_screen->h) {
			(ifs_ifs->ppi_tabColor[rect_position.x][2*rect_position.y])++;
			(ifs_ifs->ppi_tabColor[rect_position.x][2*rect_position.y+1])=i_functionNumber;	
			if(ifs_ifs->ppi_tabColor[rect_position.x][2*rect_position.y]>ifs_ifs->i_maxColor) {
				ifs_ifs->i_maxColor=ifs_ifs->ppi_tabColor[rect_position.x][2*rect_position.y];	
			}
		}
		if(10*(i+1)%(ifs_ifs->i_nbPoint)==0) {
			infoWindowIfs(ifs_ifs,(int) i);
		}
	}
}


//Retourne le nom de fichier ifs choisit par l'utilisateur
char* searchFileIfsChoice(int i_ifsNumber) {
	switch(i_ifsNumber) {
		case 1:
			return("./files_config/ifs/fern.ifs");
			break;
		case 2:
			return("./files_config/ifs/spiral.ifs");
			break;
		case 3:
			return("./files_config/ifs/dragon.ifs");
			break;
		case 4:
			return("./files_config/ifs/coral.ifs");
			break;
		case 5:
			return("./files_config/ifs/triangle.ifs");
			break;
		case 6:
			return("./files_config/ifs/floor.ifs");
			break;
		case 7:
			return("./files_config/ifs/binary.ifs");
			break;
		case 8:
			return("./files_config/ifs/koch.ifs");
			break;
		case 9:
			return("./files_config/ifs/tree.ifs");
			break;
		case 10:
			return("./files_config/ifs/fractint.ifs");
			break;
		case 11:
			return("./files_config/ifs/zigzag.ifs");
			break;	  
		default:{}
	}

	return("./files_config/ifs/dragon.ifs");
}



//bloque le redessinage de l'écran
void testLockScreenIfs(Ifs* ifs_ifs) {
	if(ifs_ifs->i_lockScreen) {
		ifs_ifs->i_lockScreen=0;
	} else {
		SDL_FillRect(ifs_ifs->surf_screen,NULL, 0x000000); 
	}
}