from chainon import Chainon

from typing import TypeVar, Generic
C = TypeVar('Chainon')
L = TypeVar('Liste')

class Liste:
    """ Une liste d'éléments """

    def __init__(self:L, tab:list=[]) ->None:
        """ Ne contient qu'un seul attribut : la tête de la liste.
        Soit c'est un objet de type Chainon, soit c'est l'objet None """
        if len(tab) == 0:
            self.head = None
        else:
            chainon = Chainon(tab[0], None)
            self.head = chainon
            for i in range(1,len(tab)):
                chainon.inserer(tab[i],i)

    def is_empty(self:L) ->bool:
        """ Renvoie True sio la liste est vide """
        return self.head is None

    def push(self:L, valeur) ->None:
        """ Ajoute en tête de liste """
        self.head = Chainon(valeur, self.head)

    def __str__(self:L) ->str:
        """ print : affiche sous forme de chaîne """
        if self.head is None:
            return "vide"
        else:
            return str(self.head)

    def __len__(self:L) ->int:
        """ len : longueur de la chaine """
        if self.head is None:
            return 0
        else:
            return len(self.head)

    def __getitem__(self:L, indice:int):
        """ Renvoie l'élément à l'indice donné """
        if self.head is None:
            raise IndexError(f"Impossible d'insérer à l'indice {indice} dans une liste vide.")
        else:
            return self.head.n_ieme_element(indice)

    def __add__(self:L, autre:L)->L:
        """ Pour utiliser l'opérateur +, il faut implémenter une méthode __add__.
        Cette méthode doit renvoyer un nouvel objet. """
        if not isinstance(autre, Liste) :
            raise TypeError(f"Impossible d'ajouter une liste de type  {type(autre)}")
        res = Liste()
        res.head = self.head.concatener(autre.head)
        return res