#include "fctConvertisseur.h"

void inverserTableau(char* un_tableau,int nbelement)
{
	int temp,i;  //variable temporaire pour l'echange et l'indice
	nbelement--; //nbelement sert aussi d'indice et de condition dans la boucle

	//cette boucle parcours la moiter du tableau et inverse les elements symetriquement
	for(i=0;i<nbelement;i++)
	{
		temp=un_tableau[i];
		un_tableau[i]=un_tableau[nbelement];
		un_tableau[nbelement]=temp;
		nbelement--;
	}
}


//******************** CONVERSSION DE X VERS 10 ********************
unsigned long XversDix(unsigned short une_BaseDepart, char* un_TabNombre, unsigned short MaxElements)
{
	unsigned short Poids = 0;
	unsigned short temp_nombre=0;
	unsigned long Resultat = 0;
	unsigned short PoidsCourant= 0;
	short trouve = 0;
	char TabAlphaNumerique[36] = {'0','1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c' , 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};

	PoidsCourant=MaxElements-1;

	printf("\n\nPour passer de la base %d a la base 10 : il faut\nfaire la somme des nombres a \nconvertir multplie par %d (leur base) a la\npuissance de leur poid.\n", une_BaseDepart, une_BaseDepart);
  getchar();

	for (Poids= 0; Poids<MaxElements;Poids++)   //Parcourir chaque element du tableau
	{
		temp_nombre = 0;
		do 
		{
			if(un_TabNombre[Poids] == TabAlphaNumerique[temp_nombre])
			{
				trouve = 1;
			}
			else
			{
				temp_nombre++;
			}
		} while(trouve==0);
		trouve = 0;
		
		Resultat=Resultat+temp_nombre*pow(une_BaseDepart,PoidsCourant);
		printf(" + ");																														//sortie ecran
		printf("%hd*%hd^%hd",temp_nombre, une_BaseDepart, PoidsCourant);
		
		if ((Poids%4==0) && (Poids!=0))
		{
			printf("\n");
		}
				
		PoidsCourant--;
	}

	PoidsCourant=MaxElements;
	printf("\nLa convertion du nombre \n%s vers la base 10 est de : \n%ld\n", un_TabNombre, Resultat);  //affichage du resultat.

	return Resultat;
}

//******************** CONVERSION DE 10 VERS X********************
char* DixVersX(unsigned short une_BaseFinale, unsigned long un_NombreDecimal)
{
	char* TabNombre  = (char *)calloc(32+1, sizeof(char));  
	char TabAlphabet[26] = {'a', 'b', 'c' , 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
	unsigned short reste;
	int Poids=0;
	int PoidsMax=0;

	/*On effectue une divisions du nombre decimal par le base finale dont le modulo est recuperé pour former le resultat,
	ceci bouclé jusqua ce que le nombre decimal soit inferieur a zero.*/

	printf("\n\nPour passer de la base 10 à la base %d il faut \neffectuer des divisions successives", une_BaseFinale);
	printf("par %d\n(la base de destination), puis lire les restes a\nl'inverse. \n\n", une_BaseFinale);
	getchar();

	for(Poids=0;un_NombreDecimal>0;Poids++)
	{
		reste = un_NombreDecimal % une_BaseFinale;
		printf("%ld / %hd = %ld reste %hd\n", un_NombreDecimal, une_BaseFinale, (un_NombreDecimal / une_BaseFinale), reste);
		if (reste < 10)
		{
			//itoa(reste, &TabNombre[Poids], 10);
			sprintf(&TabNombre[Poids], "%d", reste);
		}
		else 
		{
			TabNombre[Poids] = TabAlphabet[reste-10];
		}

		un_NombreDecimal /= une_BaseFinale;
		PoidsMax++;
		
		if ((Poids%12==0) && (Poids!=0))	//marque une pause toute les 12 lignes
		{
			getchar();
		}
				
	}

	inverserTableau(TabNombre, PoidsMax);
	//printf("\nLe resultat est : \n%s", TabNombre);

	printf(" ******** Le resultat est : ******** \n");
	for (Poids=0;Poids<PoidsMax;Poids++)
	{
		if (((PoidsMax-Poids)%4==0)&&(Poids!=0))	//Place un . a l'affichage
		{
			printf(".");
		}
		printf("%c", TabNombre[Poids]);
	}
	
	return TabNombre;
}