#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

#define Arrondir(fVal)(fVal >=0) ? (int)(fVal + 0.5) : (int)(fVal- 0.5)

#define ECART_MAX 1
#define ECART(fVal, fVal1) abs((*(int *)&fVal) - (*(int *)&fVal1))

#define TestInf(fVal) (fVal == HUGE_VAL || fVal == -HUGE_VAL)

#define TestNaN(fVal) (fVal != fVal)

union uValeur{
	int iVal;
	unsigned int uiVal;
	float fVal;
};

struct sNb{
	union uValeur uVar;
	char bType;
	struct sNb *suivant;
};

int traiterOperateur(char);
unsigned int atoui(char *acVal);
int empiler(union uValeur, char bType);
void afficherPile();
int checkNombre(char *chaine);
int atonb(char *chaine);
int checkPoint(char *chaine);
struct sNb *depiler();
char trouveTypeResultat(char type1, char type2);
int traiterOperateur(char operateur);

struct sNb *tete;

int main(){
	/*
	char choix[50];
	fflush(stdin);
	gets(choix);

	printf("%u\n", atoui(choix));

	system("pause");
	*/

	tete = NULL;
	char choix[50] = "hello";

	while(strcmp("q", choix) != 0){

		printf("Entrez un operateur (+, -, *, /, = ou a), d, q ou un nombre: ");
		fflush(stdin);
		gets(choix);
		printf("\n");

		if (checkNombre(choix) != 0){

			if (atonb(choix) == 0){
				printf("Nombre non ajouter\n");
			}

		}

		else{
			traiterOperateur(choix[0]);

		}

		afficherPile();
	}


	system("pause");

}

unsigned int atoui(char *acVal){
	// EBX VAL
	// EAX COMPTEUR
	// EDX 10^x
	int i;
	unsigned int val = 0;

	_asm{
		mov EAX, 0
		mov EBX, val
		mov EDX, 1

		boucle1:
		cmp acVal[EAX], 0
		je end1
		inc EAX
		jmp boucle1
		end1:

		mov i, eax

		sub eax, 1

		boucle:
		cmp EAX, 0
		jle end



		movsx ECX, acVal[EAX]
		sub ECX, 48
		imul ECX, EDX

		imul EDX, 10


		add EBX, ECX
		dec EAX
		mov ECX, 0
		jmp boucle

		end:

		mov val, EBX
	}
	return val;
}

int empiler(union uValeur nouvelleValeur, char bType){

	struct sNb *nouveau = malloc(sizeof(struct sNb));

	if(nouveau == NULL)
		return 0;

	nouveau->uVar = nouvelleValeur;
	nouveau->bType = bType;
	nouveau->suivant = tete;
	tete = nouveau;

	return 1;

}



int atonb(char *chaine){

	union uValeur nouveau;

	if (atof(chaine) == 0 && chaine[0] != '0')
		return 0;
	if (checkPoint(chaine) == 1){
		nouveau.fVal = (float)atof(chaine);

		if (TestInf(nouveau.fVal)){
			printf("Erreur nombre infini\n");
			return 0;
		}

		if (empiler(nouveau, 1) != 1)
			return 0;

		return 1;
	}
	if (chaine[0] == '+' || chaine[0] == '-'){
		nouveau.iVal = atoi(chaine);

		if (empiler(nouveau, 2) != 1)
			return 0;

		return 1;
	}
	else{
		nouveau.uiVal = atoi(chaine);

		if (empiler(nouveau, 3) != 1)
			return 0;

		return 1;
	}
}

void afficherPile(){

	struct sNb *next = tete;

	while (next != NULL){

		switch (next->bType){
		case 1:
			printf("<F> %f\n", next->uVar.fVal);
			break;
		case 2:
			printf("<I> %d\n", next->uVar.iVal);
			break;
		case 3:
			printf("<UI> %u\n", next->uVar.uiVal);
			break;
		default:
			printf("DEBUG: Afficher pile: switch\n");
		}


		next = next->suivant;
	}

}

int checkNombre(char *chaine){

	if ((chaine[0] >= 48 && chaine[0] <= 57) || (chaine[0] == '-' || chaine[0] == '+') && (chaine[1] >= 48 && chaine[1] <= 57))
		return 1;
	else
		return 0;

}

int checkPoint(char *chaine){

	int i = 0;

	while (chaine[i] != '\0' && i < 20){
		if (chaine[i] == '.')
			return 1;
		i++;
	}
	return 0;

}

struct sNb *depiler(){

	struct sNb *tmp;

	tmp = tete;
	tete = tmp->suivant;

	return tmp;

}

char trouveTypeResultat(char type1, char type2){

	if (type1 <= type2)
		return type1;
	else
		return type2;

}

int traiterOperateur(char operateur){

	struct sNb *operante1, *operante2;
	union uValeur resultat;

	switch (operateur){
		case 'a':
			if (tete == NULL){
				printf("Operation impossible, pile vide.\n");
				return 0;
			}
			operante1 = depiler();
			resultat.iVal = Arrondir(operante1->uVar.fVal);
			empiler(resultat, 2);
			free(operante1);
			return 1;
		break;
		case 'd':
			if (tete == NULL){
				printf("Operation impossible, pile vide.\n");
				return 0;
			}
			operante1 = depiler();
			free(operante1);
			return 1;
		break;
	}

	if (tete == NULL || tete->suivant == NULL){
		printf("Pas assez d'operante pour appliquer l'operation.\n");
		return 0;
	}

	if (operateur == '='){
		if (ECART(tete->uVar.fVal, tete->suivant->uVar.fVal) <= ECART_MAX){
			printf("Valeurs sont egales\n");
			return 1;
		}
	}



	char typeResultat;

	operante1 = depiler();
	operante2 = depiler();
	typeResultat = trouveTypeResultat(operante1->bType, operante2->bType);



	resultat.fVal = 0;

	switch (operante1->bType){
		case 1:
			resultat.fVal += operante1->uVar.fVal;
			break;

		case 2:
			resultat.fVal += operante1->uVar.iVal;
			break;

		case 3:
			resultat.fVal += operante1->uVar.uiVal;
			break;

		default:
			printf("oops\n");
	}

	switch (operante2->bType){
		case 1:
			switch (operateur){
			case '+':
				resultat.fVal += operante2->uVar.fVal;
				break;
			case '-':
				resultat.fVal -= operante2->uVar.fVal;
				break;
			case '*':
				resultat.fVal *= operante2->uVar.fVal;
				break;
			case '/':
				resultat.fVal /= operante2->uVar.fVal;
				break;
			}
		break;

		case 2:
			switch (operateur){
				case '+':
					resultat.fVal += operante2->uVar.iVal;
					break;
				case '-':
					resultat.fVal -= operante2->uVar.iVal;
					break;
				case '*':
					resultat.fVal *= operante2->uVar.iVal;
					break;
				case '/':
					resultat.fVal /= operante2->uVar.iVal;
					break;
			}
		break;

		case 3:
			switch (operateur){
				case '+':
					resultat.fVal += operante2->uVar.uiVal;
					break;
				case '-':
					resultat.fVal -= operante2->uVar.uiVal;
					break;
				case '*':
					resultat.fVal *= operante2->uVar.uiVal;
					break;
				case '/':
					resultat.fVal /= operante2->uVar.uiVal;
					break;
			}
			break;

		default:
			printf("oops\n");
	}

	switch (typeResultat){

	    case 1:
			if (TestNaN(resultat.fVal)){
				printf("Operation interdite\n");
			}
			else{
				empiler(resultat, typeResultat);
			}
			break;
		case 2:
			resultat.iVal = (int)resultat.fVal;
			empiler(resultat, typeResultat);
			break;
		case 3:
			resultat.uiVal = (unsigned int)resultat.fVal;
			empiler(resultat, typeResultat);
			break;
		default:
			printf("mouai\n");

	}
	free(operante1);
	free(operante2);
	return 1;
}