#include <stdio.h>
#include <stdlib.h>

/* Structure pour les clients. La structure est une sorte de "mode d'emploi"
 * pour la création de variable. Ainsi je peu créé une structure de type
 * Personne (et non une structure personne) que je nommerai ListeClient.
 * La variabel ListeClient (qui a été créé selon la description ci dessous donc)
 * contient un char nom, un char prenom, une char telephone et un pointeur
 * vers la personne suivante dans la liste. C'est grace a cette dernière
 * variable de type pointeur de structure personne que l'on pourra rajouter
 * de manière "infinie" des clients dans la liste. Le principe est :
 * Le client 1 a un NPT (nom, prenom, tel) + l'adresse mémoire du client 2
 * Le client 2 a un NPT + l'adresse mémoire du client 3
 * Le client 3 a un NPT + l'adresse mémoire du client 4
 * et ainsi de suite. Ce qui se trouve a la fin de la structure après le };
 * me permet d'initialiser directment une variable Personne de type Personne
 * (comme pour la variable ListeClient en fait) ainsi que une variable de type
 * pointeur sur la structure personne. L'avantage est que ces deux variables
 * peuvent être utilisé n'importe ou dans le code (elles ne sont donc pas
 * limité a la portée de leurs portions)*/
typedef struct Personne
{
        char* nom;
        char* prenom;
        char* telephone;
        // Notre pointeur pour le client suivant
        struct Personne* suivant;
        // Notre variable Personne et le pointeur de structure
}Personne, *PersonnePtr;

/* J'ecris ici les protorypes de mes fonctions. Les protoypes de fonctions
 * permettent basiquement d'appeler dans main des fonctions dont le code
 * est ecrit APRES main. Elles correspondent respectivement a l'etape
 * 1, 2 et 3 décrite par Cailleuw*/
int NombreDeClients();
PersonnePtr AjoutClient(int);
void AffichageClient(PersonnePtr);

int main()
{
        // nombreClient et le nombre rentré par le user
        int NombreClient;
        /* On crée une "liste". en fait on créé un pointeur. Un pointeur
         * référence un addresse. Et a cette addresse la on reserve un espace
         * mémoire qui esra "controlé" (référencé) par le pointeur. La taille
         * de cette espace est egale a la taille de la structure "basiquement
         * 3 char* et un Personne*)*/
        PersonnePtr ListeClient = (PersonnePtr)malloc(sizeof(Personne));

        // ETAPE 1 : On demande a l'utilisateur le nombre de clients en appelant la fonction NombreDeClients()
        NombreClient = NombreDeClients();
        // ETAPE 2 : L'utilisateur saisis les clients et on les rajoute à la liste.
        ListeClient = AjoutClient(NombreClient);
        // ETAPE 3 : On affiche la liste des clients
        AffichageClient(ListeClient);

        return 0;
}

// Version raccroucie du main
// int main()
// {
//      AffichageClient(AjoutClient(NombreDeClients()));
//      return 0;
// }

PersonnePtr AjoutClient(int nombreClient)
{
        // Création d'un nouveau pointeur de structure et allocation de la
        // mémoire a l'emplacement pointé comme au debut de main()
        PersonnePtr Client = (PersonnePtr)malloc(sizeof(Personne));

        // On récupère les informations Nom, Prenom et n° de TEL
        // Et on les stocke dans la structure pointé par Client
        printf("Saisie du nom : ", nombreClient);
        scanf("%s", &Client->nom);
        printf("Saisie du Prenom : ", nombreClient);
        scanf("%s", &Client->prenom);
        printf("Saisie du Telephone : ", nombreClient);
        scanf("%s", &Client->telephone);

        // Si il y a encore des clients a rajouté, on rappel cette fonction
        // et on stocke le pointeur de structure qu'elle retourne dans
        // suivant. (Fonction récursive)
        if (nombreClient-- >= 2 ) {
            Client->suivant = AjoutClient(nombreClient);
        }

        // Si tout les clients sont rajoutés, on renvoi la première structure
        return Client;
}

// Pas besoin d'explication pour cette fonction je pense
int NombreDeClients()
{
        int nombreClient;
        printf("Combien de clients souhaitez-vous saisir ? \n");
        scanf("%d", &nombreClient);
        return nombreClient;
}

/* Allé, encore un peu de récursif
 * La fonction prend en argument un Pointeur de Personne. En fait,
 * on lui donne a manger l'addresse a laquel se trouve l'élément à afficher.
 * (un pointeur représentant une adresse). Et vu que tous les clients on
 * l'adresse ou se trouve le client suivant, il suffit d'envoyer "suivant"
 * de la structure a la fonction jusqu'a ce que suivant soit egal a NULL et donc
 * qu'il n'y plus de client a afficher.*/
void AffichageClient(PersonnePtr ListeClient)
{
        // On affiche les infos
        // Le "&" est nécéssaire car ListeClient est un pointeur.
        // "&" permet d'obtenir la structure pointé par Listeclient et donc
        // les valeurs contenue pas la structure référencé
        printf("--------------------------------\n");
        printf("Nom : %s\n", &ListeClient->nom);
        printf("Prenom : %s\n", &ListeClient->prenom);
        printf("Telephone : %s\n", &ListeClient->telephone);

        // Si le pointeur vers le client suivant référence (pointe) quelque chose
        // alors on réappel cette fonction avec en argument l'adresse du client
        // suivant.
        if(ListeClient->suivant != NULL){
            AffichageClient(ListeClient->suivant);
        }
}