# Il ne faut pas changer l'attribut valeur quand tu évalues une expression :
#   tu mélanges la valeur de la racine et la valeur de l'expression.
# if self.valeur != '+' and ... très lourd. À remplacer par if self.valeur not in '+*/-^'
# la méthode __str__ est appelée quand on écrit str(expression), et renvoie une
#   chaine de caractères. Écrire str(self.gauche.__str__()) est donc redondant :
#   il suffit d'écrire str(self.gauche).
# Expr = Pile_chaine() : évite les majuscules sur les noms de variables, et nom
#   très mal choisi pour une pile !!
# Dans npi2tree :
#   tu fais une erreur dans l'ordre des opérations : 2 3 - devrait donner -1, pas 1
#   il faudrait aussi gérer les erreurs (par exemple 2 3 5 +)

# Note : 9 / 10

import tkinter as tk
from Pile import Pile_chaine
import random

class Expression:
    """Implémentation d'une expression mathématique dans un arbre binaire"""
    def __init__(self, valeur, gauche, droit):
        """Crée un arbre binaire vide"""
        self.valeur = valeur
        self.gauche = gauche
        self.droit = droit
        
    def evalue(self):
        """Renvoie le résultat de l'expression mathématique d'un arbre binaire"""
        if self.valeur == '+':
            self.valeur = self.gauche.evalue() + self.droit.evalue()
        elif self.valeur == '*':
            self.valeur = self.gauche.evalue() * self.droit.evalue()
        elif self.valeur == '/':
            self.valeur = self.gauche.evalue() / self.droit.evalue()
        elif self.valeur == '-':
            self.valeur = self.gauche.evalue() - self.droit.evalue()
        elif self.valeur == '^':
            self.valeur = self.gauche.evalue() ** self.droit.evalue()
        return self.valeur
    
    def __str__(self):
        """Renvoie l'expression mathématique d'un arbre binaire"""
        if self.valeur != '+' and self.valeur != '*' and self.valeur != '/' and self.valeur != '-' and self.valeur != '^':
            return self.valeur
        else:
            return "(" + str(self.gauche.__str__()) + str(self.valeur) + str(self.droit.__str__()) + ")"
        
    

def npi2tree(ch):
    """Renvoie un arbre binaire contenant une expression mathématique
    via une expression en notation polonaise inversée"""
    ch = ch.split()
    Expr = Pile_chaine()
    for elmt in ch:
        if elmt == '*' or elmt == '+' or elmt == '/' or elmt == '-' or elmt == '^':
            exp = Expression(elmt, Expr.depiler(), Expr.depiler())
            Expr.empiler(exp)
        else:
            Expr.empiler(Expression(int(elmt), None, None))
    return Expr.sommet()
    



def calculer():
    """Affiche l'expression ainsi que son résultat dans l'interface Tkinter"""
    déception = ["Peut mieux faire.",
            "Va t'entraîner, t'es nul...",
            "Ah nan, tu pues vraiment.",
            "Skill issue.",
            "Je souhaite que tu arrêtes tout.",
            "Il a eu 0/20",
            "Apprends à lire.",
            "Arrête de déconner.",
            "Abandonne au pire.",
            "42",
            "Va faire un tour dehors."
            ]
    expression = entry.get()
    try:
        resultat = npi2tree(expression).evalue()
        result_label.config(text="Résultat: " + str(npi2tree(expression)) + " = " + str(resultat))
    except:
        result_label.config(text=random.choice(déception))

root = tk.Tk()
root.title("Calculatrice rudimentaire")

message_label = tk.Label(root, text="Le calcul doit être écrit en notation polonaise inversée")
message_label.pack()

entry = tk.Entry(root, width=30)
entry.pack(pady=10)

evaluate_button = tk.Button(root, text="Calculer", command=calculer)
evaluate_button.pack()

result_label = tk.Label(root, text="")
result_label.pack(pady=10)

root.mainloop()