#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include "include.h"
#define NB_CASES_TABLEAU 50

int main(void)
{
    //===============
    // = Question 1 =
    //===============
    t_pile* debut_pile;

    debut_pile=(t_pile*)malloc(sizeof(t_pile));

    assert(debut_pile!=NULL);

    debut_pile->pt_suiv=NULL;
    debut_pile->pt_noeud=NULL;

    // Création de l'arbre

    t_noeud *arbre;
    arbre = NULL;

    char operation[NB_CASES_TABLEAU];

    // déclaration des variables utiles lors de la lecture en entrée

    printf("Ecrivez votre expression : ");

    //traitement chaine de caractere
    printf("before");
    scanf("%s", operation); // On écrit dans le tableau operation, de 50 cases avec l'entrée classique (clavier)
    printf("After");
    // Remplissage de l'arbre

    //creer_arbre(&arbre,debut_pile,operation);
    printf("Arbre créé");

    // Affichage post fixé

    imprime_postfixe(arbre);
    printf("\n");

    // affichage infixé

    imprime_infixe(arbre);
    printf("\n");

    return 0;
}
//=============================================================

// =============
// = FONCTIONS =
// =============

// ==================================================================
// Fonction empiler : Permet d'empiler un caractère
//
// Entrée : Prend en paramètre le début de la liste
// Entrée : Prend en paramètre un caractère
// Retour : Retourne la nouvelle tête de liste
//
// ==================================================================

t_noeud* empiler(t_pile* a, char car, t_noeud* pt_gauche, t_noeud* pt_droit)
{

    t_noeud* noeud;
    noeud = NULL;

    t_pile* maillon;
    maillon = NULL;


    // CREATION D'UN NOEUD
    noeud = creer_noeud(car,pt_gauche, pt_droit);

    // CREATION D'UN MAILLON DE LA PILE
    maillon = creer_maillon(noeud);

    // INSERTION DU MAILLON
    a = insertion_maillon_en_tete(maillon,&a);


    return noeud;
}

// ==================================================================
// Fonction créer_noeud : Permet de créer un noeud de l'arbre
// ==================================================================

t_noeud* creer_noeud(char info, t_noeud* pt_gauche, t_noeud* pt_droit)
{
    t_noeud* noeud;
    noeud = (t_noeud*)malloc(sizeof(t_noeud));

    noeud->info = info;
    noeud->pt_suiv_gauche= pt_gauche;
    noeud->pt_suiv_droit= pt_droit;
    return noeud;
}

// ==================================================================
// Fonction créer_maillon : Permet de créer un maillon de la liste
// ==================================================================

t_pile* creer_maillon(t_noeud* noeud)
{
    t_pile* pile;
    pile = (t_pile*) malloc(sizeof(t_pile));

    pile->pt_noeud = noeud;
    pile->pt_suiv = NULL;
    return pile;
}

// ==================================================================
// Fonction Insertion : Permet d'insérer un maillon en tête de liste
// ==================================================================

t_pile* insertion_maillon_en_tete(t_pile* maillon,t_pile** a)
{
    maillon->pt_suiv = *a; // On copie l'adresse du maillon vers laquelle pointe a, le début de la liste
    *a= maillon; // On fait pointer notre début de liste vers le nouveau maillon inséré
    return *a; // On retourne un pointeur sur la tête de liste
}

// ==================================================================
// Fonction Dépiler : Permet de dépiler le premier maillon de la pile
//
// Entrée : Prend en paramètre le début de la liste
// Retour : Retourne le noeud contenu dans le maillon
//
// ==================================================================

t_noeud* depiler(t_pile* a) // Permet de dépiler le premier maillon
{
    t_pile* retour; // On créer un retour qui retournera
    retour = a->pt_suiv; // On récupère le maillon qui contiendra le premier noeud

    a->pt_suiv = retour->pt_suiv; // Une fois que le noeud à dépilé est trouvé, on fait pointer le début de notre liste vers le maillon suivant

    return retour->pt_noeud; // Retourne
}


// ==================================================================
// Fonction créer_arbre : Permet de créer l'arbre
// ==================================================================

t_noeud* creer_arbre(t_noeud** abr, t_pile* a, char chaine[])
{
    printf("On rentre dans créer arbre");
    // Création de deux noeuds permettant de stocker les noeuds retournés par la fonction dépiler

    t_noeud* noeud_retourne_1;
    t_noeud* noeud_retourne_2;

    t_noeud* noeud;

    int j = 0;

    while(chaine[j] != '\0' ) // Tant qu'il reste des caractères à traiter
    {

            if(noeud->info == '+' || noeud->info == '-' || noeud->info == '*' || noeud->info == '/' || noeud->info == '%') // Si l'info est un opérateur
            {
                // On dépile les noeuds stockés (= opérandes)

                noeud_retourne_1 = depiler(a->pt_suiv);
                noeud_retourne_2 = depiler(a->pt_suiv); // Doit normalement marcher puisque dépiler gère dans son coin pour les raccordements

                // On empile le noeud créé

                noeud = empiler(a,chaine[j],noeud_retourne_1,noeud_retourne_2);
            }

            else if(noeud->info == '0' || noeud->info == '1' || noeud->info == '2' || noeud->info == '3' || noeud->info == '4' || noeud->info == '5' || noeud->info == '6' || noeud->info == '7' || noeud->info == '8' || noeud->info == '9')
            {
                empiler(a, chaine[j], NULL, NULL);
            }
    }
    return noeud;
}

// ==================================================================

void imprime_postfixe(t_noeud *abr)
{
    t_noeud *pt1 = abr;

    if(pt1->pt_suiv_gauche == NULL && pt1->pt_suiv_droit == NULL)
    {
        printf("%c ",pt1->info);
    }
    else
    {
        printf("(");
        imprime_postfixe(pt1->pt_suiv_gauche);
        imprime_postfixe(pt1->pt_suiv_droit);
        printf("%c) ",pt1->info);
    }
}

// ==================================================================

void imprime_infixe(t_noeud *abr)
{
    if(abr->pt_suiv_gauche == NULL && abr->pt_suiv_droit == NULL)
    {
        printf("%c ",abr->info);
    }
    else
    {
        printf("(");
        imprime_infixe(abr->pt_suiv_gauche);
        printf("%c ",abr->info);
        imprime_infixe(abr->pt_suiv_gauche);
        printf(") ");
    }
}