class Node:
    """La classe ```Node``` sera un noeud (une case, un emplacement, ...) où l'on stockera notre donnée

    Les objets de cette classe ont deux attributs:

    value: qui correspond à la valeur stockée
    nxt: la référence vers le prochain élément

    """

    def __init__(self, value=None, nxt=None) -> None:
        """Initialisation du "node"

        :param value: valeur à stocker dans ce "node"
        :param nxt: Node du prochain élément

        :consignes: compléter l'initialisation de la classe.

        :example:
        >>> n1 = Node(1)
        >>> assert n1.value == 1
        >>> assert n1.nxt is None
        >>> n2 = Node(5, n1)
        >>> assert n2.value == 5
        >>> assert n2.nxt == n1
        >>> n3 = Node("a", n2)
        >>> assert n3.value == "a"
        >>> assert n3.nxt == n2
        """
        self.value = value
        self.nxt = nxt


class Pile:
    """
    La classe ```Pile``` doit posséder un élément "courant" qui est l'élément sur le dessus de la pile.

    Fonctionnement d'une pile

      -----------
      _ _ _ _ _ <---- append
      -----------

      -----------
      _ _ _ _ _ ----> pop
      -----------


    Elle doit aussi posséder un entier ```n``` qui compte le nombre d'éléments dans la pile

    Cette classe aura donc 2 attributs:
    - current avec l'élément courant
    - n avec le nombre d'éléments dans la pile

    :consignes: Compléter les méthodes suivantes.
    """

    def __init__(self) -> None:
        """Initialisation de la Pile vide

        :example:
        >>> pile = Pile()
        >>> assert pile.n == 0
        >>> assert pile.current is None
        """
        self.current = None
        self.n = 0

    def append(self, value):
        """Ajoute "value" dans la pile

        :example:
        >>> pile = Pile()
        >>> pile.append(1)
        >>> assert pile.n == 1
        >>> assert pile.current.value == 1
        >>> pile.append("a")
        >>> assert pile.n == 2
        >>> assert pile.current.value == "a"
        """
        self.current = Node(value, nxt=self.current)
        self.n += 1

    def get_current(self):
        """Renvoie la prochaine valeur sans l'enlever de la pile
        Si la liste est vide, la fonction renvoie None.

        :example:
        >>> pile = Pile()
        >>> pile.get_current()
        >>> pile.append(3)
        >>> pile.get_current()
        3
        >>> pile.get_current()
        3
        """
        if not self.is_empty():
            return self.current.value

    def is_empty(self):
        """Vérifie si le pile est vide

        :example:
        >>> pile = Pile()
        >>> pile.is_empty()
        True
        >>> pile.append(1)
        >>> pile.is_empty()
        False

        """
        return self.current is None

    def pop(self):
        """Renvoie le prochain élément de la pile et l'enlève.

        Comme c'est une pile, le prochain élément est le dernier élément arrivé.

        Si la liste est vide, la fonction renvoie None.

        :example:
        >>> pile = Pile()
        >>> pile.pop()
        >>> pile.append(2)
        >>> pile.pop()
        2
        >>> pile.pop()
        >>> pile.append(2)
        >>> pile.append(5)
        >>> pile.append("a")
        >>> pile.pop()
        'a'
        >>> pile.pop()
        5
        >>> pile.pop()
        2
        >>>

        """
        if not self.is_empty():
            a = self.current.value
            self.current = self.current.nxt
            self.n -= 1
            return a

    def empty(self):
        """vide la pile c'est à dire element tous les elements de cette dernière

        :example:
        >>> pile = Pile()
        >>> pile.append(3)
        >>> pile.append(5)
        >>> pile.append("a")
        >>> pile.get_current()
        'a'
        >>> assert pile.n == 3
        >>> pile.empty()
        >>> pile.get_current()
        >>> assert pile.n == 0
        """
        while not self.is_empty():
            self.pop()