"""
Il aurait été intéressant de laisser quelques te,sts.
Que se passe-t-il si liste_npi n'est pas valide 
"""

from Pile import Pile_lst


class Expression:
    """
    Représente une expression arithmétique sous forme d’arbre binaire.
    """

    def __init__(self, valeur, gauche=None, droit=None):
        """
        Initialise un noeud avec une valeur ('+', '*' ou entier)
        et éventuellement deux sous-arbres gauche et droit.
        """
        self.valeur = valeur
        self.gauche = gauche
        self.droit = droit

    def evalue(self):
        """
        Évalue récursivement l'expression et renvoie sa valeur entière.
        """
        # Cas feuille (entier)
        if self.gauche is None and self.droit is None:
            return self.valeur

        # Cas opérateur
        if self.valeur == "+":
            return self.gauche.evalue() + self.droit.evalue()
        elif self.valeur == "*":
            return self.gauche.evalue() * self.droit.evalue()
        else:
            raise ValueError("Opérateur inconnu")

    def __str__(self):
        """
        Renvoie une chaîne représentant l’expression avec parenthèses.
        """
        # Cas feuille
        if self.gauche is None and self.droit is None:
            return str(self.valeur)

        # Cas opérateur
        return "(" + str(self.gauche) + self.valeur + str(self.droit) + ")"


def npi2tree(liste_npi):
    """
    Convertit une liste d’éléments en notation polonaise inversée (NPI)
    en un arbre d’expression de type Expression.
    """
    pile = Pile_lst()

    for elem in liste_npi:

        # Si c'est un opérateur
        if elem == "+" or elem == "*":
            droit = pile.depiler()
            gauche = pile.depiler()
            exp = Expression(elem, gauche, droit)
            pile.empiler(exp)

        # Sinon c'est un entier
        else:
            nombre = int(elem)
            exp = Expression(nombre, None, None)
            pile.empiler(exp)

    return pile.sommet()