Projet NF05

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

struct Passenger
{
    struct Flight* flight; //Pointeur vers le vol sur lequel le vol est inscrit
    struct Luggage* luggages[2]; //Tableau contenant les bagages du passager
    char* last_name;
    char* first_name;
    char* nationality;
    int priority; //0 pour non-priotaire, 1 pour prioritaire
    int seat; //Numéro de la place du passager dans l'avion
    int birthday[3]; // [0] = jour, [1] = mois, [2] = année
    int ticket; //Numéro du ticket du passager (généré aléatoirement)
    char* passport; //Numéro de passeport (2 chiffres, 2 lettres, 5 chiffres)
    int etape; //Correspond à l'étape du scénario à laquelle se situe le passager, 0 pour l'étape d'inscription, 1 enregistrement, 2 passage des frontières, 3 passage de la sécurité, 4 embarquement, 5 en vol

    int struct_size; //Taille d'un élément "Passenger"
};

struct Flight
{
    int registered_passengers_count; //Nombre de passagers enregistres sur le vol
    int onboard_passengers_count; //Nombre de passagers ayant embarques
    int seats; //Nombre de places dans le vol
    int rows; //Nombre de rangées
    int columns; //Nombre de colonne
    int seats_per_column; //Nombre de place par colonne sur une rangée
    int tickets_available; //Nombre de places disponibles à l'achat
    int luggage_slots; //Poids maximum des bagages
    int luggages_weight; //Poids de tous les bagages chargés
    char* destination; //Destination du vol
    int* occupied_seats; //Tableau des places occupes 0 -> pour place libre | 1 -> pour réservée | 2 -> pour passager assis

    int took_off; //0 si le vol n'a pas décollé, 1 si le vol a décollé

    int struct_size; //Taille d'un élément "Flight"
};

struct Luggage
{
    struct Passenger* owner; //Pointeur vers le passager propriétaire du bagage
    int priority; //Priorité du bagage 0 pour pas prioritaire, 1 pour prioritaire
    float weight; //Poids du bagage en kg
    int ticket; //Numéro ticket du bagage (généré aléatoirement)
    int boarded; //0 si le bagage n'est pas chargé, 1 si le bagage est chargé

    int struct_size; //Taille d'un élément "Luggage"
};

int what_to_do, count, i;
struct Passenger **passengers;  int passengers_length;  int passengers_size;
struct Flight **flights;        int flights_length;     int flights_size;


//Fonctions qui sont necessaires au fonctionnement du programme
struct Flight*      create_flight(struct Flight *f, int rows, int columns, int seats_per_column, int luggage_slots, char destination[]); //Instanciation d'un élément de structure Flight
struct Passenger*   create_passenger(struct Passenger *p, struct Flight *flight, char last_name[], char first_name[], int priority, int birthday[], int ticket, char *passport, char* nationality); //Instanciation d'un élément de structure Passenger
struct Luggage*     create_luggage(struct Luggage *l, struct Passenger *p, int priority, float weight); //Instanciation d'un élément de structure Luggage

//Scenario
void                add_passengers(); //etape 0 -> achat des billets pour les passagers
void                add_flights(); //Création des vols
void                register_passenger(); // etape 1 -> enregistrement d'un passager sur un vol
void                register_luggage(struct Passenger *p); //Création des bagages
void                borders_passenger(); //etape 2 -> faire passer les frontières à un passager
void                security_passenger(); //etape 3 -> faire passer la sécurité
void                board_passengers(); //etape 4 -> embarquement des passagers sur un vol
void                board_luggages(); //chargement des bagages sur un vol
void                flight_take_off(); //etape 5 -> décollage de l'avion

//Procedures menu
void flight_menu(); //Menu interface vol
void passenger_menu(); //Menu interface passagers
void modify_passenger_menu(); //Menu de modification des passagers

//Procédures d'affichage
void show_flights(); //Afficher toutes les infos relatives aux vols
void show_passengers(struct Passenger** p, int length); //Afficher toutes les infos relatives aux passagers
void show_registered_on_flight(); //Affiche toutes les infos des passagers enregistrés sur un vol
void show_occupied_seats_on_flight(struct Flight *f); //Affiche toutes les places sur un vol et leur état

//Fonctions qui simplifient la vie
char*   input_string(); //Permet d'entrer une chaîne de caractères et de la stocker dans un pointeur
struct Passenger**  get_registered_passengers_on_flight(int id); //Récupère la liste des passagers enregistrés sur un vol
struct Passenger*   find_passenger(char* name, int ticket); //Récupère un passager selon son nom ou son ticket

int main()
{
    time_t t;
    srand((unsigned) time(&t)); //Permet de créer une "seed" qui est nécessaire au fonctionnement de la fonction "rand()" utilisée plus tard dans le programme

    what_to_do = 1; //Ces variables sont globales et sont définies dans le fichier "functions.h"
    passengers_length = 0;
    flights_length = 0;

    printf("Bienvenue dans votre programme de gestion d'aeroport !\n");
    printf("Qu'allez-vous pouvoir faire ?\n");
    printf("Nous allons tout d'abord vous demander de mettre en place votre aeroport, en specifiant les vols disponibles.\n");
    printf("Vous allez ensuite pouvoir effectuer toute une panoplie d'actions pour simuler le fonctionnement de l'aeroport.\n");
    printf("Amusez-vous bien !\n");

    printf("Puisque vous venez de lancer le programme, il y a quelques premieres etapes necessaires au bon fonctionnement de l'application a effectuer.\n");
    printf("Veuillez nous indiquer combien de vol(s) seront disponibles a l'ouverture de votre aeroport.\n");
    scanf("%d", &count); getchar(); //count est aussi globale

    add_flights(); //Avant de commencer à utiliser le programme, l'utilisateur doit créer un ou plusieurs vol(s).
    flights_length = count;

    do {
        printf("\nEntrer le nombre correspondant a l'action a effectuer.\n");
        printf("0 - Quitter\n");
        printf("1 - Gerer les vols\n");
        printf("2 - Gerer les passagers\n");
        scanf("%d", &what_to_do);

        switch(what_to_do)
        {
            case 0:
                printf("Merci de votre utilisation. A bientot !\n");
                return 0; //Quitte le programme
                break;
            case 1:
                flight_menu(); //Menu des vols
                break;
            case 2:
                passenger_menu(); //Menu des passagers
                break;
        }
    } while(what_to_do != 0);
}


struct Flight *create_flight(struct Flight *f, int rows, int columns, int seats_per_column, int luggage_slots, char destination[])
{
    int array_size = 0; //La taille du tableau "destination"
    while(destination[array_size] != '\0')
    {
        array_size++;
    }
    array_size++; //On connaît sa taille, on va pouvoir attribuer toute la mémoire nécessaire

    int seats = rows * columns * seats_per_column; //On sait combien de la place le vol compte. On stocke un entier par place dans le tableau "occupied_seats"

    f = realloc(f, sizeof(*f) + array_size + seats*sizeof(int)); //On ajuste la mémoire à la taille exacte dont nous avons besoin
    f->seats = seats; //On procède à l'initialisation des attributs de la structure
    f->rows = rows;
    f->columns = columns;
    f->seats_per_column = seats_per_column;
    f->luggage_slots = luggage_slots;
    f->luggages_weight = 0;
    f->took_off = 0;
    f->tickets_available = seats;

    int i;
    f->occupied_seats = malloc(seats*sizeof(int));
    for(i=0;i<seats;i++)
    {
        f->occupied_seats[i] = 0; //On initialise les cases du tableau à 0 (toutes les places sont au départ disponibles)
    }

    f->destination = malloc(array_size); //Juste ce qu'il faut
    for(i=0;i<array_size;i++)
    {
        f->destination[i] = destination[i]; //On copie le tableau
    }

    f->registered_passengers_count = 0;
    f->onboard_passengers_count = 0;
    f->struct_size = sizeof(*f) + array_size  + seats*sizeof(int); //C'est la taille propre à chaque structure, on s'en sert pour allouer la mémoire nécessaire pour tout stocker dans les tableaux globaux "flights" et "passengers"

    return f;
}

struct Passenger *create_passenger(struct Passenger *p, struct Flight *flight, char last_name[], char first_name[], int priority, int birthday[], int ticket, char* passport, char* nationality)
{
    int first_name_size = 0, last_name_size = 0, birthday_size = 3 * sizeof(int), luggage_size = 2 * sizeof(struct Luggage), nationality_size = 0;

    while(last_name[last_name_size] != '\0')
    {
        last_name_size++;
    }
    last_name_size++; //On connaît la taille de son nom de famille

    while(first_name[first_name_size] != '\0')
    {
        first_name_size++;
    }
    first_name_size++; //De son prénom

    while(nationality[nationality_size] != '\0')
    {
        nationality_size++;
    }
    nationality_size++; //De sa nationalité

    p = realloc(p, sizeof(*p) + first_name_size + last_name_size + birthday_size + flight->struct_size + luggage_size + 10 + nationality_size); //On attribut la mémoire nécessaire. "10" correspond à la taille du la chaîne "passport" qui contient 9 caractères et le caractère '\0'
    p->flight = flight;
    p->priority = priority;
    p->ticket = ticket;
    p->etape = 0;

    int i;

    p->last_name = malloc(last_name_size);
    for(i=0;i<last_name_size;i++)
    {
        p->last_name[i] = last_name[i]; //On copie
    }

    p->first_name = malloc(first_name_size);
    for(i=0;i<first_name_size;i++)
    {
        p->first_name[i] = first_name[i]; //On copie
    }

    for(i=0;i<3;i++)
    {
        p->birthday[i] = birthday[i]; //On copie
    }

    p->passport = malloc(10);
    for(i=0;i<10;i++)
    {
        p->passport[i] = passport[i]; //On copie
    }

    p->nationality = malloc(nationality_size);
    for(i=0;i<nationality_size;i++)
    {
        p->nationality[i] = nationality[i]; //On copie
    }

    p->struct_size = sizeof(*p) + first_name_size + last_name_size + birthday_size + flight->struct_size + luggage_size + 10 + nationality_size; //On se souvient de la taille exacte de cette structure

    return p;
}

struct Luggage* create_luggage(struct Luggage *l, struct Passenger *p, int priority, float weight)
{
    l = realloc(l, sizeof(*l) + p->struct_size);
    l->owner = p;
    l->priority = priority;
    l->weight = weight;
    l->ticket = rand() % 1000000000; //On génère aléatoirement le numéro du bagage
    l->boarded = 0;

    l->struct_size = sizeof(*l) + p->struct_size;

    return l;
}

void show_flights() //Affichage de tous les vols et de leurs infos infos
{
    for(int i=0;i<flights_length;i++)
    {
        printf("|----\t NUMERO DE VOL :    %d   \t----|\n", i);
        printf("|----\t Destination :      %s   \t----|\n", flights[i]->destination);
        printf("|    \t Nombre inscrits :  %d   \t    |\n", flights[i]->registered_passengers_count);
        printf("|    \t Nombre embarques : %d   \t    |\n", flights[i]->onboard_passengers_count);
        printf("|    \t Nombre places :    %d   \t    |\n", flights[i]->seats);
        printf("|    \t Bagages max :      %dkg \t    |\n", flights[i]->luggage_slots);
        printf("|    \t Bagages charges :  %dkg \t    |\n", flights[i]->luggages_weight);
        printf("|----\t-------------------------\t----|\n");
    }
}

void show_registered_on_flight() //Affichage de tous les passagers enregistrés sur un vol
{
    int flight_id;
    show_flights();
    printf("De quel vol voulez-vous afficher les passagers enregistres ?\n");
    do {
        scanf("%d", &flight_id);
        if(flight_id > flights_length-1 || flight_id < 0) printf("Ce vol n'existe pas. Veuillez entrer l'ID du vol.\n");
    } while(flight_id > flights_length-1 ||flight_id < 0);

    show_passengers(get_registered_passengers_on_flight(flight_id), flights[flight_id]->registered_passengers_count);

}

void show_passengers(struct Passenger** p, int length) //Affiche les infos des passagers contenus dans un tableau de pointeurs de taille length
{
    printf("------------------------------\n");
    for(i=0;i<length;i++)
    {
        printf("%s %s\n", p[i]->first_name, passengers[i]->last_name);

        int day = p[i]->birthday[0];
        int month = p[i]->birthday[1];
        int year = p[i] -> birthday[2];

        printf("Date de naissance : ");

        if(day < 10) //On formatte la date de naissance pour afficher des dates telles que 01/01/2000 et non 1/1/2000
        {
            printf("0%d", day);
        }
        else
        {
            printf("%d", day);
        }

        printf("/");

        if(month<10)
        {
            printf("0%d", month);
        }
        else
        {
            printf("%d", month);
        }

        printf("/%d\n", year);
        printf("Prioritaire : "); //On transforme le 1 et le 0 en "oui" et "non"
        if(p[i]->priority == 1)
        {
            printf("oui");
        }
        else
        {
            printf("non");
        }
        printf("\n");

        printf("Numero de passeport : %s\n", p[i]->passport);
        printf("Numero de billet : %d\n", p[i]->ticket);
        printf("Etape : "); //On affiche l'étape en fonction du code
        switch(p[i]->etape) {
            case 0:
                printf("Achat billet\n");
                break;
            case 1:
                printf("Enregistrement\n");
                break;
            case 2:
                printf("Passage des frontieres\n");
                break;
            case 3:
                printf("Passage de la securite\n");
                break;
            case 4:
                printf("Embarquement\n");
                break;
            case 5:
                printf("En vol.\n");
                break;
        }

        printf("Nationalite : %s\n", p[i]->nationality);

        printf("------------------------------\n");
    }
}


void show_occupied_seats_on_flight(struct Flight *f) //On affiche la distribution des places dans un vol
{
    printf("\n0 -> Place disponible | 1 -> Place reservee | 2 -> Passager assis\n\n");

    int i;
    for(i=0;i<f->seats;i++)
    {
        printf("%d", f->occupied_seats[i]); //On afficje l'état de chaque place
        if((i+1) % (f->seats_per_column * f->columns) == 0) //On revient à la ligne après chaque rangée
        {
            printf("\n");
        }
        else if((i+1) % f->seats_per_column == 0) //On met un pipe entre chaque colonne
        {
            printf(" | ");
        }
        else //On met un espace entre chaque place
        {
            printf(" ");
        }
    }
    printf("\n");
}


void flight_menu() //Le menu de gestion des vols
{
    printf("\nEntree dans le menu vol. Quelle action voulez-vous effectuer ?\n");
    printf("0 - Retour au menu principal\n");
    printf("1 - Ajouter un ou plusieurs vols\n");
    printf("2 - Afficher les vols\n");
    printf("3 - Afficher les passagers enregistres sur un vol.\n");
    printf("4 - Afficher la distribution des places sur un vol.\n");
    printf("5 - Embarquer les passagers sur un vol.\n");
    printf("6 - Charger les bagages sur un vol.\n");
    printf("7 - Faire decoller un vol.\n");
    scanf("%d", &what_to_do); getchar();
    switch(what_to_do) {
        case 0:
            printf("Retour au menu principal.\n");
            what_to_do = 1;
            return; //On quitte le menu de gestion des vols
            break;
        case 1:
            printf("Combien de vols voulez-vous ajouter ?\n");
            scanf("%d", &count); getchar(); //count est globale, et sera utilisée dans add_flights
            add_flights();
            flights_length += count; //On ajoute count vols au nombre total de vols
            if(count > 1) printf("Vos vols ont bien ete ajoutes !\n");
            else printf("Votre vol a bien ete ajoute !\n");
            break;
        case 2:
            printf("Affichage de tous les vols !\n");
            show_flights(); //Affichage des vols
            break;
        case 3:
            show_registered_on_flight(); //Affichage des passagers enregistrés sur un vol
            break;
        case 4:
            show_flights(); //Affichage des vols afin que l'utilisateur puisse choisir pour quel vol afficher la distribution des places
            int flight_id;
            printf("De quel vol voulez-vous afficher la distribution des places occupees ?\n");
            do {
                scanf("%d", &flight_id);
                if(flight_id > flights_length-1 || flight_id < 0) printf("Ce vol n'existe pas. Veuillez entrer l'ID du vol.\n");
            } while(flight_id > flights_length-1 ||flight_id < 0);
            struct Flight *f = flights[flight_id];
            show_occupied_seats_on_flight(f); //Affichage de la distribution des places
            break;
        case 5:
            printf("Preparation a l'embarquement des passagers...\n");
            board_passengers(); //Procédure d'embarquement des passagers
            break;
        case 6:
            printf("Preparation au chargement de bagages...\n");
            board_luggages(); //Procédure du chargement des bagages
            break;
        case 7:
            printf("Preparation au decollage d'un avion...\n");
            flight_take_off(); //Décollage d'un avion
        default:
            what_to_do = 1;
            return; //Par défaut, on retourne au menu principal
            break;
    }
}

void passenger_menu() //Menu de la gestion des passagers
{
    printf("\nEntree dans le menu passager. Quelle action voulez-vous effectuer ?\n");
    printf("0 - Retour au menu principal\n");
    printf("1 - Ajouter un ou plusieurs passagers\n");
    printf("2 - Afficher les passagers\n");
    printf("3 - Enregistrer un passager\n");
    printf("4 - Faire passer les frontieres a un passager\n");
    printf("5 - Faire passer la securite a un passager.\n");
    printf("6 - Modifier un passager.\n");
    scanf("%d", &what_to_do); getchar();
    switch(what_to_do) {
        case 0:
            printf("Retour au menu principal.\n");
            what_to_do = 1;
            return; //Retour au menu principal
            break;
        case 1:
            printf("Combien de passagers voulez-vous ajouter ?\n");
            scanf("%d", &count); getchar(); //Pareillement au menu des vols, count est globale est sera utilisée dans add_passengers()
            add_passengers();
            passengers_length += count; //On ajoute le nombre de passagers ajoutés au nombre total de passagers
            if (count > 1) printf("Les passagers ont bien ete ajoutes !\n"); //Toujours de la grammaire...
            else printf("Le passager a bien ete ajoute !\n");
            break;
        case 2:
            printf("Affichage de tous les passagers...\n");
            show_passengers(passengers, passengers_length);
            break;
        case 3:
            printf("Demarrage de la procedure d'enregistrement.\n");
            register_passenger(); //Procédure d'enregistrement des passagers
            break;
        case 4:
            printf("Demarrage de la procedure du passage des frontieres.\n");
            borders_passenger(); //etc
            break;
        case 5:
            printf("Demarrage de la procedure du passage de la securite.\n");
            security_passenger();
            break;
        case 6:
            modify_passenger_menu(); //Voir... juste en-dessous !
            break;
    }
}

void modify_passenger_menu()
{
    printf("Liste de tous les passagers : \n");
    show_passengers(passengers, passengers_length);

    printf("Comment voulez-vous choisir le passager a modifier ?\n");
    printf("\t- Par son numero de billet (0)\n");
    printf("\t- Par son nom (1)\n");
    int procedure, i, success = 0;
    struct Passenger *p;
    scanf("%d", &procedure); getchar();
    switch(procedure)
    {
    case 0:
        printf("Entrer le numero de ticket du passager a modifier.\n");

        int ticket;
        scanf("%d", &ticket); getchar();

        p = find_passenger(NULL, ticket);

        break;
    case 1:
        printf("Entrer le nom du passager a modifier.\n");

        char* nom;
        nom = input_string();

        p = find_passenger(nom, -1);

        break;
    }
    if(p != NULL)
    {
        do {
            printf("\nVeuillez choisir l'action a effectuer sur %s %s.\n", p->first_name, p->last_name);
            printf("0 - Revenir au menu principal\n");
            printf("1 - Modifier le prenom\n");
            printf("2 - Modifier le nom\n");
            printf("3 - Modifier la nationalite\n");
            printf("4 - Modifier la priorite\n");
            printf("5 - Modifier l'anniversaire\n");
            printf("6 - Modifier le passeport\n");
            printf("7 - Modifier les bagages\n");
            printf("8 - Modifier le vol\n");
            scanf("%d", &what_to_do); getchar(); //Quel attribut du passager l'utilisateur veut-il modifier ?

            passengers_size -= p->struct_size;

            switch(what_to_do) {
                case 0:
                    what_to_do = 1;
                    return; //Retour au menu principal
                    break;
                case 1:
                    printf("Entrer le nouveau prenom de %s %s : ", p->first_name, p->last_name);
                    char *first_name = input_string();
                    p = create_passenger(p, p->flight, p->last_name, first_name, p->priority, p->birthday, p->ticket, p->passport, p->nationality); //C'est pour cela que dans la fonction create_passenger(...) on réalloue la mémoire au lieu de simplement l'allouer. Si on l'allouait simplement, le tableau des passager contiendrait après cela une adresse erronée ! On aurait alors (et on en eu d'ailleurs...) une erreur de segmentation.
                    break;
                case 2:
                    printf("Entrer le nouveau nom de %s %s : ", p->first_name, p->last_name);
                    char *last_name = input_string();
                    p = create_passenger(p, p->flight, last_name, p->first_name, p->priority, p->birthday, p->ticket, p->passport, p->nationality); //Du coup, on recrée une strucuture semblable à celle avant la modification, on change juste l'attribut qui nous intéresse
                    break;
                case 3:
                    printf("Nationalite : %s.\n", p->nationality);
                    printf("Entrer la nouvelle nationalite de %s %s : ", p->first_name, p->last_name);
                    char *nationality = input_string();
                    p = create_passenger(p, p->flight, p->last_name, p->first_name, p->priority, p->birthday, p->ticket, p->passport, nationality);
                    break;
                case 4:
                    printf("Priorite: %d.\n", p->priority);
                    printf("Entrer la nouvelle priorite de %s %s (0 : non-prioritaire | 1 : prioritaire) : ", p->first_name, p->last_name);
                    scanf("%d", &p->priority); getchar();
                    break;
                case 5:
                    printf("Changement de la date de naissance de %s %s.\n", p->first_name, p->last_name);
                    printf("Jour : "); scanf("%d", &p->birthday[0]);
                    printf("Mois : "); scanf("%d", &p->birthday[1]);
                    printf("Annee : "); scanf("%d", &p->birthday[2]); getchar(); //Là on peut directement aller modifier les valeurs de birthday, car c'est un tableau statique
                    break;
                case 6:
                    printf("Entrer le nouveau numero de passeport de %s %s (2 chiffres, 2 lettre, 5 chiffres) : ", p->first_name, p->last_name);
                    char *passport = input_string();
                    p = create_passenger(p, p->flight, p->last_name, p->first_name, p->priority, p->birthday, p->ticket, passport, p->nationality);
                    break;
                case 7:
                    printf("Nouvelle procedure d'enregistrement des bagages pour %s %s.\n", p->first_name, p->last_name);
                    register_luggage(p); //On écrase les précédents bagages par les nouveaux
                    break;
                case 8: //Le cas le plus complexe, le changement de vol
                    show_flights();
                    if(p->etape > 0 && p->etape != 5)
                    {
                        p->flight->occupied_seats[p->seat] = 0; //On met directement la place du passager comme étant libre
                    }
                    p->flight->tickets_available++; //La place est disponible à l'achat
                    if(p->etape > 3)
                    {
                        p->flight->onboard_passengers_count--; //Si le passager était embarqué, il ne l'est plus
                    }

                    if(p->etape > 0)
                    {
                        p->flight->registered_passengers_count--; //Si le passager était enregistré, il ne l'est plus
                    }

                    p->etape = 0; //Annulation de l'enregistrement

                    printf("Veuillez choisir un nouveau vol pour %s %s.\n", p->first_name, p->last_name);
                    printf("Entrer l'ID du nouveau vol : ");
                    int flight_id;
                    do {
                        scanf("%d", &flight_id);
                        if(flight_id > flights_length-1 || flight_id < 0) printf("Ce vol n'existe pas. Veuillez entrer l'ID du vol du passager.\n");
                        else
                        {
                            if(flights[flight_id]->tickets_available - 1 == 0)
                            {
                                printf("Desole, ce vol est deja plein. Annulation de la modification de passager.\n");
                                return;
                            }
                            else if (flights[flight_id]->took_off == 1)
                            {
                                printf("Desole, ce vol a deja decolle. Annulation de la modification de passager.\n");
                                return;
                            }
                        }
                    } while(flight_id > flights_length-1 ||flight_id < 0);

                    getchar();

                    p->flight = flights[flight_id]; //On le met sur le nouveau vol
                    flights[flight_id]->tickets_available--; //Le nouveau a donc une place de disponible en moins
                    break;
            }

            passengers_size += p->struct_size;
            passengers = (struct Passenger**) realloc(passengers, passengers_size);

        } while(0 == 0); //Tête à toto !
    }
}

void add_passengers()
{
    if(count == 1) //Pour la grammaire !!
    {
        printf("Generation de 1 passager...\n");
    }
    else if(count > 1)
    {
        printf("Generation de %d passagers...\n", count); //On note le 's' qui fait la différence...
    }

    int i;
    for(i=passengers_length;i<passengers_length+count;i++) //Ok, on répète ces instructions pour les count passagers à créer
    {
        char* first_name; char* last_name; int priority; int birthday[3]; char* passport; int flight_id; char* nationality; //Toutes les variables pour créer le passager

        printf("Veuillez saisir le prenom du passager : "); //Explicite
        first_name = input_string();
        printf("Veuillez saisir le nom du passager : ");
        last_name = input_string();
        printf("Ce passager est-il un passager prioritaire ? Oui (1) / Non (0)\n");
        scanf("%d", &priority);
        int correct = 0; //Cette variable va permettre de savoir si la date rentrée par la suite sera valide
        do {
            printf("Veuillez saisir la date de naissance du passager.\n"); //Ici c'est un peu piégeux, il faut gérer le calendrier grégorien avec les années bissextiles.
            printf("Jour : ");
            scanf("%d", &birthday[0]); //Jour
            printf("Mois (un nombre) : ");
            scanf("%d", &birthday[1]); //Mois
            printf("Annee : ");
            scanf("%d", &birthday[2]); getchar(); //Année, et on vide le buffer
            if(birthday[2] > 1900 && birthday[2] < 2021 && birthday[0] >= 1 && birthday[1] >= 1 && birthday[1] <= 12) // Si le passager est né avant 1900, c'est sans doute un fantôme. On ne gère pas les passagers fantômes. S'il est né après 2020 (et encore on est sympas...), c'est un voyageur du temps. Cas que l'on ne gère pas non plus. Et puis, s'il peut voyager dans le temps, pourquoi prend-il l'avion dans un premier temps ??? A coup sûr, il a des moyens de transports bien plus avancés.
            {
                switch(birthday[1]) {
                    case 1:
                    case 3:
                    case 5:
                    case 7:
                    case 8:
                    case 10:
                    case 12: //Mois classiques
                        if(birthday[0] <= 31)
                        {
                            correct = 1; //Oui ! La date entrée est valide.
                        }
                        break;
                    case 2: //Février....
                        if((birthday[2] % 4 == 0 && birthday[2] % 100 != 0) || birthday[2] % 400 == 0) //Si c'est une année bissextile
                        {
                            if(birthday[0] <= 29)
                            {
                                correct = 1;
                            }
                        }
                        else //Si année classique
                        {
                            if(birthday[0] <= 28)
                            {
                                correct = 1;
                            }
                        }
                        break;
                    default: //Mois de 30 jours
                        if(birthday[0] <= 30)
                        {
                            correct = 1;
                        }
                        break;
                }
            }
            if(correct == 0) //"correct" est toujours à 0, la date rentrée n'est pas valide.
            {
                printf("La date que vous avez saisie n'est pas valide. Veuillez recommencer.\n");
            }
        } while(correct != 1); //On réessaye

        printf("Veuillez entrer le numero de passeport du passager. (2 chiffres, 2 lettres, 5 chiffres)\n"); //Explicite
        passport = input_string();
        printf("Veuillez entrer la nationalite du passager.\n");
        nationality = input_string();
        printf("Voici tous les vols disponibles.\n");
        show_flights(); //On affiche tous les vols disponibles pour le passager.
        printf("Veuillez entrer l'ID du vol du passager.\n"); //L'ID du vol est en fait sa place dans le tableau qui stocke tous les vols.
        do {
            scanf("%d", &flight_id);
            if(flight_id > flights_length-1 || flight_id < 0) printf("Ce vol n'existe pas. Veuillez entrer l'ID du vol du passager.\n"); //On va bien faire attention à l'ID que l'utilisateur va entrer afin de ne pas accéder à un endroit inconnu dans la mémoire.
            else
            {
                if(flights[flight_id]->tickets_available-1 == 0) //Si le vol n'a plus de places disponibles
                {
                    printf("Desole, ce vol est deja plein. Annulation de la creation de passager.\n");
                    return;
                }
                else if (flights[flight_id]->took_off == 1) //Si le vol est déjà parti
                {
                    printf("Desole, ce vol a deja decolle. Annulation de la creation de passager.\n");
                    return;
                }
            }
        } while(flight_id > flights_length-1 ||flight_id < 0); //Et on réessaye

        getchar(); //On vide le buffer
        int ticket = rand() % 1000000000; //On crée un numéro de billet aléatoire

        struct Passenger *p = (struct Passenger*) malloc(sizeof(p)); //Dans la fonction create_passenger(...) on utilise realloc et non malloc, il faut donc avoir allouer de la mémoire auparavant. Pour comprendre ce choix, voir la fonction "modify_passenger()" dans le fichier "menu_fonctions.c"
        p = create_passenger(p, flights[flight_id], last_name, first_name, priority, birthday, ticket, passport, nationality); //Et on crée le passager ! On verra dans les commentaires de la fonction "create_passenger()"" ce qu'il se passe exactement

        if(i == 0) //Si c'est le TOUT PREMIER passager créé, il faut pour la première fois allouer de la mémoire pour le tableau de pointeurs des passagers
        {
            passengers_size = p->struct_size; //p->struct_size est la taille de l'élément p dans la mémoire. Et passengers_size est la taille totale de tous les éléments stockés dans la variable "passengers" qui est le fameux tableau de tous les passagers.
            passengers = (struct Passenger**) malloc(passengers_size); //Il n'y a que p dans la mémoire, donc on allue pile poil la place pour p
        }
        else
        {
            passengers_size += p->struct_size; //On ajoute la taille de l'élément p à la taille de tous les passagers
            passengers = (struct Passenger**) realloc(passengers, passengers_size); //Et on réalloue la mémoire pour avoir assez de place pour tout le monde !
        }

        passengers[i] = p; //Maintenant qu'on a assez de place, on affecte p au tableau, à la bonne place
        flights[flight_id]->tickets_available--; //Et on soustrait une place de disponible sur le vol de p

    }
}

void add_flights()
{
    if(count == 1) //Pour la grammaire ! (encore)
    {
        printf("Generation de 1 vol...\n");
    }
    else if(count > 1)
    {
        printf("Generation de %d vols...\n", count);
    }

    int i;
    for(i=flights_length;i<flights_length+count;i++) //On répète l'opération autant de fois que l'utilisateur souhaite ajouter de vols
    {
        char* destination; int luggage_slots, rows, colums, seats_per_column; //Les variables nécessaires pour créer un vol

        printf("Veuillez saisir la destination du vol : "); //Explicite
        destination = input_string();
        printf("Indication : un vol avec 10 rangees, 2 colonnes et 2 places par colonne aura en tout 40 places (10 x 2 x 2 = 40).\n");
        printf("Veuillez saisir le nombre de rangees de ce vol : ");
        scanf("%d", &rows); getchar();
        printf("Veuillez saisir le nombre de colonnes de ce vol : ");
        scanf("%d", &colums); getchar();
        printf("Veuillez saisir la largeur en sieges d'une colonne dans ce vol : ");
        scanf("%d", &seats_per_column); getchar();
        luggage_slots = rows * colums * seats_per_column * 23 * 2; //On calcule le nombre de bagages maximum dans un avion automatiquement. * 23 * 2 car chaque passager peut avoir jusqu'à deux bagages de vingt-trois kilos.

        struct Flight *f = (struct Flight*) malloc(sizeof(f));
        f = create_flight(f, rows, colums, seats_per_column, luggage_slots, destination); //Et on crée le vol !

        if(i == 0) //Premier vol
        {
            flights_size = f->struct_size; //De manière analogue à la création de passager, flight_size représente la taille de tous les éléments "Flight" stockés dans "flights"
            flights = (struct Flight**) malloc(flights_size); //Faire de la place pour le premier vol
        }
        else
        {
            flights_size += f->struct_size; //On fait de la place pour le nouveau vol
            flights = (struct Flight**) realloc(flights, flights_size); //Et on l'applique
        }

        flights[i] = f; //Assez de place, on affecte.
    }
}

void register_passenger()
{
    //C'est parti pour l'enregistrement d'un passager !
    printf("Liste de tous les passagers : \n");
    show_passengers(passengers, passengers_length); //Affichage de tous les passagers

    printf("Comment voulez-vous identifier le passager a enregistrer ?\n");
    printf("\t- Par son numero de billet (0)\n");
    printf("\t- Par son nom (1)\n");
    int procedure, i, success = 0; //procedure pour la méthode d'identification du passager, i un compteur, et success une variable qui nous permettra de demander des choses simples à l'utilisateur
    struct Passenger *p;
    scanf("%d", &procedure); getchar();
    switch(procedure)
    {
    case 0: //Identification par billet
        printf("Entrer le numero de ticket du passager a enregistrer.\n");

        int ticket;
        scanf("%d", &ticket); getchar();

        p = find_passenger(NULL, ticket); //On trouve le passager en question grâce au billet, et on le garde dans un pointeur

        break;
    case 1: //Identification par nom
        printf("Entrer le nom du passager a enregistrer.\n");

        char* nom;
        nom = input_string();

        p = find_passenger(nom, -1); //On trouve le passager en question grâce à son nom, et on le garde dans un pointeur

        break;
    }

    if(p != NULL && p->etape == 0) //On vérifie qu'on a bien trouvé le passager, et qu'il n'a pas encore passer cette étape
    {
        p->etape++; //Il passe à l'étape suivante
        printf("%s %s a ete enregistre(e) sur le vol a destination de %s.\nSon boarding pass a bien ete cree.\n", p->first_name, p->last_name, p->flight->destination);

        p->flight->registered_passengers_count += 1; //On incrémente le nombre d'enregistrés sur le vol
        printf("Voulez-vous enregistrer des bagages pour ce passager ? Oui (1) ou Non (0)\n");
        scanf("%d", &success);
        if(success == 1) //L'utilisateur veut-il enregistrer des passagers ?
        {
            register_luggage(p); //On enregistre des bagages pour le passager
        }

        printf("Il faut desormais attribuer une place au passager. Choisissez la methode de choix : Automatique (1) ou Manuelle (0)\n");
        scanf("%d", &success);

        printf("Affichage du vol.\n");
        show_occupied_seats_on_flight(p->flight); //On affiche la distribution des places dans le vol
        int seat, row, column, seat_on_column; //Entrées utilisateurs (s'il choisit la méthode manuelle)
        if(success == 1)
        {
            do {
                row = rand() % p->flight->rows; //On choisit un rang aléatoire
                column = rand() % p->flight->columns; //On choisit une colonne aléatoire
                seat_on_column = rand() % p->flight->seats_per_column; //Et on choisit une place aléatoire dans la colonne
                seat = row * p->flight->columns * p->flight->seats_per_column + column * p->flight->seats_per_column + seat_on_column; //On calcule le numéro de la place pour le tableau
            } while(p->flight->occupied_seats[seat] != 0); //Et si la place est déjà prise on recommence !

            p->flight->occupied_seats[seat] = 1; //Ok, maintenant la place est occupée.
            p->seat = seat; //On donne au passager son numéro de place
            printf("La place pour le passager se situe est la place %d sur la rangee %d de la colonne %d.\n", seat_on_column+1, row+1, column+1); //Et on lui fait savoir
        }
        else
        {
            printf("Nombre de rangees : %d\n", p->flight->rows); //On fait savoir clairement à l'utilisateur de combien de rangées/colonnes/places par colonne l'avion dispote-t-il.
            printf("Nombre de colonnes : %d\n", p->flight->columns);
            printf("Nombre de places par colonne : %d\n", p->flight->seats_per_column);

            do {
                printf("Entrez la rangee : ");
                scanf("%d", &row);
                if(row > p->flight->rows || row < 0)
                {
                    printf("La rangee demandee n'est pas valide.\n");
                }
            } while(row > p->flight->rows || row < 0); //On vérifie la validité, sinon le numéro de place généré pourrait nous faire accéder à un endroit inconnu de la mémoire

            do {
                printf("Entrez la colonne : ");
                scanf("%d", &column);
                if(column > p->flight->columns || column < 0)
                {
                    printf("La colonne demandee n'est pas valide.\n");
                }
            } while(column > p->flight->columns || column < 0);

            do {
                printf("Entrez la rangee : ");
                scanf("%d", &seat_on_column);
                if(seat_on_column > p->flight->seats_per_column || seat_on_column < 0)
                {
                    printf("La place demandee n'est pas valide.\n");
                }
            } while(seat_on_column > p->flight->seats_per_column || seat_on_column < 0);

            row--; //On sait que l'utilisateur n'a pas l'habitude des tableaux en C, et que c'est une personne normale : il va donc commencer à compter à partir de 1 et non de 0
            column--;
            seat_on_column--;


            seat = row * p->flight->columns * p->flight->seats_per_column + column * p->flight->seats_per_column + seat_on_column; //On calcule le numéro de place demandée par le passager
            p->flight->occupied_seats[seat] = 1; //La place est désormais occupée
            p->seat = seat; //On affecte au passager sa place
        }
        printf("Affichage du vol avec la place nouvellement reservee.\n");
        show_occupied_seats_on_flight(p->flight); //Et on affiche le vol maintenant que le passager à réserver sa place
    }
    else if(p != NULL && p->etape > 0) //Si le passager avait déjà passé cette étape
    {
        printf("%s %s est deja enregistre(e) sur le vol a destination de %s.\n", p->first_name, p->last_name, p->flight->destination);
    }
}

void register_luggage(struct Passenger *p)
{
    int priority = p->priority; //La priorité du bagage est la même que celle du passager
    float weight; //Poids du bagage
    if(priority == 1) //Si le passager est prioritaire
    {
        printf("%s %s est un passager prioritaire. Il est possible d'enregistrer jusqu'a deux bagages.\n", p->first_name, p->last_name);
        int i, slots;

        do {
            printf("Combien de bagages voulez-vous enregistrer ? (2 max)\n");
            scanf("%d", &slots);
        } while(slots > 2 || slots < 1); //L'utilisateur a choisi d'enregistrer des bagages, il est donc obligé d'en enregistrer entre un et deux

        for(i=0;i<2;i++) //Les tableaux bagages de chaque passager ont deux cases
        {
            if(i>=slots) //Si on dépasse le nombre de bagages à enregistrer
            {
                p->luggages[i] = NULL; //Le bagage n'existe pas
            }
            else //Sinon
            {
                do {
                    printf("Entrer le poids du bagage en kilogrammes (max 23kg).\n");
                    scanf("%f", &weight);
                } while(weight > 23 && weight < 0); //On demande le poids du bagage, et on vérifie qu'il ne dépasse pas 23kg
                struct Luggage *l = (struct Luggage*) malloc(sizeof(l));
                l = create_luggage(l, p, priority, weight); //On crée le bagage !
                p->luggages[i] = l; //On l'affecte au passager
                printf("L'ID du ticket bagage prioritaire genere est #%d.\n", l->ticket); //Et on affichage son numéro
            }
        }
    }
    else //Si le passager n'est pas prioritaire
    {
        printf("%s %s n'est pas un passager prioritaire. Il est possible d'enregistrer un bagage.\n", p->first_name, p->last_name);
        printf("Entrer le poids du bagage en kilogrammes (max 23kg).\n");
        do {
            scanf("%f", &weight);
        } while(weight > 23 && weight < 0); //On vérifie que le poids ne dépasse pas 23kg, et qu'il est supérieur à zéro
        struct Luggage *l = (struct Luggage*) malloc(sizeof(l));
        l = create_luggage(l, p, priority, weight);
        p->luggages[0] = l; //On l'affecte au passager non-prioritaire...
        p->luggages[1] = NULL; //... qui n'a le droit qu'à un seul bagage. L'autre n'existe pas
        printf("L'ID du ticket bagage genere est #%d.\n\n", l->ticket); //On affiche le numéro du bagage
    }

    printf("L'enregistrement des bagages est termine.\n");
}

void borders_passenger()
{   //Notre passager va désormais passer les frontières. On ne recommentera pas les lignes et procédures identiques à celles décrites dans "register_passenger()"
    printf("Liste de tous les passagers : \n");
    show_passengers(passengers, passengers_length);

    printf("Comment voulez-vous identifier le passager qui passe les frontieres ?\n");
    printf("\t- Par son numero de billet (0)\n");
    printf("\t- Par son nom (1)\n");
    int procedure, i, success = 0;
    struct Passenger *p;
    scanf("%d", &procedure); getchar();
    switch(procedure)
    {
    case 0:
        printf("Entrer le numero de ticket du passager qui passe les frontieres.\n");

        int ticket;
        scanf("%d", &ticket); getchar();

        p = find_passenger(NULL, ticket);

        break;
    case 1:
        printf("Entrer le nom du passager qui passe les frontieres.\n");

        char* nom;
        nom = input_string();

        p = find_passenger(nom, -1);

        break;
    }

    if(p != NULL && p->etape == 1) //Si le passager est à la bonne étape
    {
        int success = 0, besoin_visa; //besoin_visa stockera si le passager a besoin ou non d'un visa

        int destination; //Pour répondre aux QCM

        printf("Nous avons besoin de plusieurs indications vous concernant.\n");

        do {
            printf("Veuillez-choisir votre type de destination :\n");
            printf("\t1 - Europe\n");
            printf("\t2 - Hors Europe\n");
            scanf("%d", &destination);
        } while(destination < 1 || destination > 2); //On distingue deux cas principaux

        int europeen;
        do {
            printf("De quelle nationale etes-vous :\n");
            printf("\t1 - Europeen\n");
            printf("\t2 - Non-europeen\n");
            scanf("%d", &europeen);
        } while(europeen < 1 || europeen > 2); //On distingue deux cas principaux

        if(destination == 1 && europeen == 1) //Si le passager est européen et qu'il voyage en Europe, il n'a logiquement pas besoin de Visa
        {
            printf("Vous pouvez continuer, vous n'avez pas besoin de Visa.\n");
            success = 1;
            besoin_visa = 0;
        }
        else if(destination == 1 && europeen == 2) //Si le passager n'est pas européen et qu'il voyage en Europe, il a besoin d'un visa Schengen
        {
            besoin_visa = 1; //Oui
            int schengen; //En possède-t-il un ?
            do {
                printf("Possedez-vous un visa Schengen ?\n");
                printf("\t1 - Oui\n");
                printf("\t2 - Non\n");
                scanf("%d", &schengen);
            } while(schengen < 1 || schengen > 2);

            if(schengen == 1) //Super ! Il a son visa, il peut passer les frontières !
            {
                printf("Tres bien, vous pouvez continuer.\n");
                success = 1;
            }
            else //Mince... Il va devoir trouver un visa avant de pouvoir passer les frontières
            {
                printf("Desole, il vous faut un visa Schengen pour pouvoir continuer.\n");
            }
        }
        else if(destination == 2 && europeen == 1) //Si le passager ne voyage pas en Europe et il est Européen
        {
            besoin_visa = 1; //Oui
            int visa;
            do {
                printf("Possedez-vous un visa pour votre destination ?\n");
                printf("\t1 - Oui\n");
                printf("\t2 - Non\n");
                scanf("%d", &visa);
            } while(visa < 1 || visa > 2);

            if(visa == 1) //S'il possède un visa pour sa destination, tout va bien, il peut passer les frontières
            {
                printf("Tres bien, vous pouvez continuer.\n");
                success = 1;
            }
            else //Sinon, il faut qu'il s'en procure un avant de pouvoir continuer
            {
                printf("Desole, il vous faut un visa pour votre destination pour pouvoir continuer.\n");
            }
        }
        else if(destination == 2 && europeen == 2) //Si le passager n'est pas européen, et il ne voyage pas en Europe
        {
            int origine;
            do {
                printf("Retournez-vous dans votre pays d'origine ?\n");
                printf("\t1 - Oui\n");
                printf("\t2 - Non\n");
                scanf("%d", &origine);
            } while(origine < 1 || origine > 2);

            if(origine == 1) //S'il retourne dans son pays d'origine, il n'a logiquement pas besoin de Visa
            {
                printf("Vous n'avez pas besoin de visa. Vous pouvez continuer.\n");
                besoin_visa = 0;
                success = 1;
            }
            else //Il a besoin d'un visa
            {
                besoin_visa = 1;
                int visa;
                do {
                    printf("Possedez-vous un visa pour votre destination ?\n");
                    printf("\t1 - Oui\n");
                    printf("\t2 - Non\n");
                    scanf("%d", &visa);
                } while(visa < 1 || visa > 2);

                if(visa == 1) //Il peut passer les frontières
                {
                    printf("Tres bien, vous pouvez continuer.\n");
                    success = 1;
                }
                else //Il ne peut pas passer les frontières
                {
                    printf("Desole, il vous faut un visa pour votre destination pour pouvoir continuer.\n");
                }
            }
        }

        if(success == 1) //Si le passager peut passer les frontières, on affiche sa destination, sa nationalité et s'il a ou non besoin d'un visa
        {
            printf("Infos concernant %s %s :\n", p->first_name, p->last_name);
            printf("\tDestination : %s\n", p->flight->destination);
            printf("\tNationalite : %s\n", p->nationality);
            printf("\tBesoin de Visa : ");
            if(besoin_visa == 1) printf("oui\n");
            else printf("non\n");
            p->etape++; //Le passager passe à l'étape suivante
        }
    }
    else if(p != NULL && p->etape > 1) //Si le passager a déjà passé cette étape
    {
        printf("Ce passager a deja passe les frontieres.\n");
    }
    else if(p != NULL && p->etape < 1) //Si le passager ne peut pas encore passer cette étape
    {
        printf("Ce passager doit d'abord s'enregistrer.\n");
    }
}

void security_passenger()
{ //Notre passager va désormais passer la sécurité
    printf("Liste de tous les passagers : \n");
    show_passengers(passengers, passengers_length);

    printf("Comment voulez-vous identifier le passager qui passe la securite ?\n");
    printf("\t- Par son numero de billet (0)\n");
    printf("\t- Par son nom (1)\n");
    int procedure, i, success = 0;
    struct Passenger *p;
    scanf("%d", &procedure); getchar();
    switch(procedure)
    {
    case 0:
        printf("Entrer le numero de ticket du passager qui passe la securite.\n");

        int ticket;
        scanf("%d", &ticket); getchar();

        p = find_passenger(NULL, ticket);

        break;
    case 1:
        printf("Entrer le nom du passager qui passe la securite.\n");

        char* nom;
        nom = input_string();

        p = find_passenger(nom, -1);

        break;
    }

    if(p != NULL && p->etape == 2) //Le passager en est bien à cette étape...
    {
        printf("Vous etes autorise a prendre un bagage en cabine avec vous. Le bagage ne peut contenir de contenants (bouteilles, pommades, fiole, etc.). Il vous sera demande plus tard si vous souhaitez prendre des contenants avec vous.\n");

        float poids;
        do {
            printf("Le poids d'un bagage a main ne peut depasser 12kg. Si votre bagage fait plus de 12kg, veuillez retirer des objets.\n");
            printf("Quel est le poids de votre bagage ?\n");
            scanf("%f", &poids);
        } while(poids > 12 && poids < 0); //Le passager a le droit à un bagage pesant jusque 12kg. Si le bagage pèse 0kg, on part du principe qu'il n'a pas de bagage à main. Le poids ne peut pas malgré tout être négatif. (ou alors le bagage flotte dans les airs)

        int choix;
        do {
            printf("Voulez-vous prendre des contenants avec vous ? Les contenants ne peuvent depasser 100mL chacun, et vous ne pouvez avoir plus d'1L de contenants sur vous.\n");
            printf("\t1 - Oui\n");
            printf("\t2 - Non\n");
            scanf("%d", &choix);
        } while(choix < 1 || choix > 2);

        if(choix == 1) //Si le passager prend avec lui des contenants
        {
            int nb;
            int i;
            float volume;
            float total; //tout ce dont on a besoin de savoir
            do {
                printf("Combien de contenants voulez-vous prendre avec vous ?\n");
                scanf("%d", &nb);

                total = 0;
                for(i=0;i<nb;i++) //Pour chaque contenant
                {
                    printf("Veuillez entrer le volume du contenant en mL : ");
                    scanf("%f", &volume);
                    if(volume > 100) printf("Desole, votre contenant ne peut depasser les 100mL.\n"); //Si le contenant dépasse 100mL, le passager ne peut pas le prendre avec lui.
                    else total += volume; //Sinon on ajoute le volume au total des volumes
                }

                if(total > 1000) //Si le total est supérieur à 1L, le passager doit recommencer la procédure pour prendre avec lui des contenants.
                {
                    printf("Le volume total des contenants ne peut depasser 1000mL ! Votre volume : %.2f. Veuillez recommencer.\n", total);
                }
            } while(total > 1000);
        }

        printf("Votre bagage a main possede-t-il un des objets parmis les suivants ?\n"); //On s'intéresse à ce que contient le bagage du passager, et on espère surtout qu'il est honnête, car notre aéroport est un peu vieux et n'a pas encore la technologie "Rayons X"
        printf("\t- Objet tranchant\n");
        printf("\t- Grande batterie lithium\n");

        int reponse;
        do {
            printf("Choix :\n");
            printf("\t1 - Oui\n");
            printf("\t2 - Non\n");
            scanf("%d", &reponse);
        } while(reponse < 1 || reponse > 2);

        if(reponse == 1) //On retire simplement les objets, rien ne se passe
        {
            printf("Les objets a caractere dangeureux ont ete retires.\n");
        }

        printf("Votre bagage a main possede-t-il un des objets parmis les suivants ?\n");
        printf("\t- Substances illicites\n");
        printf("\t- Armes\n");
        printf("\t- Explosif\n");

        do {
            printf("Choix :\n");
            printf("\t1 - Oui\n");
            printf("\t2 - Non\n");
            scanf("%d", &reponse);
        } while(reponse < 1 || reponse > 2);

        if(reponse == 1) //Ok, là le passager est dangeureux, et fou puisqu'il déclare de lui-même posséder ces objets
        {
            printf("Le passager a ete emmene au poste de police. Il n'apparait plus sur la liste de passagers.\n");
            struct Passenger *last = passengers[passengers_length-1]; //On va déplacer le passager en dernière position du tableau à la place du passager à supprimer
            passengers_size -= p->struct_size; //On soustrait la taille de l'élément p que nous allons supprimer à la taille totale dans la mémoire du tableau passengers
            p->flight->registered_passengers_count--; //On a supprimé un passager enregistré du vol
            p->flight->tickets_available++; //Et donc une place disponible de plus sur le vol
            p->flight->occupied_seats[last->seat] = 0;
            p = create_passenger(p, last->flight, last->last_name, last->first_name, last->priority, last->birthday, last->ticket, last->passport, last->nationality); //On copie (en quelques sortes) le dernier passager à la place de p
            free(last->luggages); //On libère la mémoire occupée par la dernière case du tableau
            free(last->last_name);
            free(last->first_name);
            free(last->nationality);
            free(last->passport);
            free(last);
            passengers_length--; //Une case en moins dans le tableau passengers
            passengers = (struct Passenger**) realloc(passengers, passengers_size); //On réalloue la mémoire à la bonne valeur
        }
        else //Ca va, le passager est normal il peut embarquer
        {
            printf("Tres bien. Vous allez pouvoir proceder a l'embarquement sous peu.\n");
            p->etape++; //Il passe à l'étape suivante
        }
    }
    else if(p != NULL && p->etape >= 3)
    {
        printf("%s %s a deja passe la securite !\n", p->first_name, p->last_name);
    }
    else if(p != NULL)
    {
        printf("%s %s ne peut pas encore passer la securite.\n", p->first_name, p->last_name);
    }
}

void board_passengers()
{// On embarque tous les passagers sur un vol
    printf("Affichage des vols.\n");
    show_flights(); //Affichage des vols

    int flight_id;
    printf("Veuillez entrer l'ID du vol sur lequel embarquer les passagers : ");
    do {
        scanf("%d", &flight_id);
        if(flight_id > flights_length-1 || flight_id < 0) printf("Ce vol n'existe pas. Veuillez entrer l'ID du vol.\n");
        else if(flights[flight_id]->took_off == 1) printf("Ce vol a deja decolle ! Annulation.\n");
    } while(flight_id > flights_length-1 || flight_id < 0);

    struct Flight *f = flights[flight_id]; //Le vol sur lequel les passagers vont essayer d'être embarqués
    struct Passenger **registered_passengers = get_registered_passengers_on_flight(flight_id); int registered_passengers_length = f->registered_passengers_count; //Tout ce que l'on a besoin de savoir sur les passagers enregistrés sur le vol
    struct Passenger **registered_passengers_priority = (struct Passenger**) malloc(0); int registered_passengers_priority_length = 0, registered_passengers_priority_size = 0; //Tout ce que l'on a besoin de savoir sur les passagers enregistrés et priotaires sur le vol
    struct Passenger **registered_passengers_no_priority = (struct Passenger**) malloc(0); int registered_passengers_no_priority_length = 0, registered_passengers_no_priority_size = 0; //Tout ce que l'on a besoin de savoir sur les passagers enregistrés et non-prioritaires sur le vol
    int i;
    for(i=0;i<registered_passengers_length;i++) //Pour chaque passager enregistré
    {
        if(registered_passengers[i]->etape == 3) //S'il vient de passer la sécurité
        {
            if(registered_passengers[i]->priority == 0) //S'il n'est pas prioritaire
            {
                registered_passengers_no_priority_size += registered_passengers[i]->struct_size;
                registered_passengers_no_priority = realloc(registered_passengers_no_priority, registered_passengers_no_priority_size);
                registered_passengers_no_priority[registered_passengers_no_priority_length] = registered_passengers[i];
                registered_passengers_no_priority_length++;
                //On le met dans le tableau des non-prioritaires
            }
            else //Sinon
            {
                registered_passengers_priority_size += registered_passengers[i]->struct_size;
                registered_passengers_priority = realloc(registered_passengers_priority, registered_passengers_priority_size);
                registered_passengers_priority[registered_passengers_priority_length] = registered_passengers[i];
                registered_passengers_priority_length++;
                //On le met dans le tableau des prioritaires
            }
        } //A noter, si le passager n'est pas exactement à l'étape 3, deux cas se distinguent. Soit le passager a déjà embarqué et alors tout va bien. Soit le passager n'a pas encore passé la sécurité et ne peut donc pas encore embarqué. Pour être attendu sur un vol, le passager doit s'être enregistré. Un simple achat du billet ne lui assure aucunement que le vol l'attende pour partir.
    }

    printf("Veuillez desormais confirmer l'embarquement de chaque passager sur l'avion. 1 pour confirmer, 0 pour retarder.\n");
    printf("Tant que tous les passagers n'auront pas embarque, l'avion ne pourra pas decoller.\n");
    printf("Embarquement des passagers prioritaires...\n");

    int confirmer;//On regarde si on peut décoller
    for(i=0;i<registered_passengers_priority_length;i++) //On commence (toujours) par s'occuper des passagers prioritaires qui ont passé la sécurité
    {
        struct Passenger* p = registered_passengers_priority[i];
        do {
            printf("Confirmer l'embarquement de %s %s : ", p->first_name, p->last_name);
            scanf("%d", &confirmer); //On demande à l'utilisateur s'il souhaite confirmer l'embarquement du passager
        } while(confirmer < 0 || confirmer > 1);

        if(confirmer == 1) //Confirmation
        {
            p->etape++; //Le passager est embarqué
            f->onboard_passengers_count++; //Un passager embarqué en plus sur le vol
            f->occupied_seats[p->seat] = 2; //Le passager est assis désormais
        }
    }

    if(f->onboard_passengers_count == registered_passengers_priority_length) //Si on a autant de passagers prioritaires dans l'avion que de passagers priotaires enregistrés
    {
        printf("Embarquement des passagers non-prioritaires...\n");
        for(i=0;i<registered_passengers_no_priority_length;i++) //On refait la même chose pour les non-prioritaires !
        {
            struct Passenger* p = registered_passengers_no_priority[i];
            do {
                printf("Confirmer l'embarquement de %s %s : ", p->first_name, p->last_name);
                scanf("%d", &confirmer);
            } while(confirmer < 0 || confirmer > 1);

            if(confirmer == 1)
            {
                p->etape++;
                f->onboard_passengers_count++;
                f->occupied_seats[p->seat] = 2;
            }
        }

        printf("Affichage du vol avant le decollage...\n");
        show_occupied_seats_on_flight(f); //Affichage des passagers assis, des places réservées et des places libres dans le vol

        printf("Affichage de tous les passagers n'ayant pas embarques...\n");
        for(i=0;i<registered_passengers_length;i++) //On affiche les passagers qui n'ont pas encore embarqué (s'il y en a)
        {
            struct Passenger *p = registered_passengers[i];
            if(p->etape <= 3)
            {
                printf("%s %s n'a pas embarque.\n", p->first_name, p->last_name);
            }
        }
    }
    else //Tous les passagers priotaires n'ont pas encore embarqué !
    {
        printf("Tous les passagers prioritaires n'ont pas encore embarques. L'embarquement des passagers non-prioritaires debutera lorsque tous les passagers prioritaires auront embarques.\n");
    }

    printf("Calcul du taux de remplissage de l'avion...\n");

    float taux = (float)f->onboard_passengers_count/f->seats * 100; //Niveau... 4ème ? 5ème ? Bref on fait un pourcentage
    printf("L'avion est rempli a %.2f%%\n", taux); //"L'avion est rempli à 20,00%" par exemple
}

void board_luggages()
{ //Embarquement des bagages sur un vol
    printf("Affichage des vols.\n");
    show_flights();

    int flight_id;
    printf("Veuillez entrer l'ID du vol sur lequel charger les bagages : ");
    do {
        scanf("%d", &flight_id);
        if(flight_id > flights_length-1 || flight_id < 0) printf("Ce vol n'existe pas. Veuillez entrer l'ID du vol.\n");
        else if(flights[flight_id]->took_off == 1) printf("Ce vol a deja decolle ! Annulation.\n");
    } while(flight_id > flights_length-1 || flight_id < 0);

    printf("Chargement des bagages. 1 pour valider, 0 pour refuser.\n");
    struct Passenger **registered_passengers = get_registered_passengers_on_flight(flight_id); int registered_passengers_count = flights[flight_id]->registered_passengers_count; //On récupère tous les passagers enregistrés sur le vol
    int i;
    for(i=0;i<registered_passengers_count;i++) //Pour chaque passager
    {
        struct Passenger* p = registered_passengers[i];
        if(p->priority == 1) //Si le passager est prioritaire il peut avoir jusqu'à deux bagages
        {
            for(int j=0;j<2;j++) //Pour chaque bagage
            {
                if(p->luggages[j] != NULL) //S'il possède un bagage
                {
                    if(p->luggages[j]->boarded == 0) //Si le bagage n'est pas encore embarqué
                    {
                        int charger;
                        do {
                            printf("Charger le bagage #%d de %s %s qui pese %fkg : ", p->luggages[j]->ticket, p->first_name, p->last_name, p->luggages[j]->weight);
                            scanf("%d", &charger);
                        } while(charger < 0 || charger > 1);

                        if(charger == 1) //Il faut charger le bagage
                        {
                            p->luggages[j]->boarded = 1; //Le bagage est chargé
                            p->flight->luggages_weight += p->luggages[j]->weight; //L'avion pèse un peu plus lourd
                        }
                    }
                }
            }
        }
        else //Si le passager n'est pas priotaire il peut avoir un seul bagage
        {
            if(p->luggages[0] != NULL) //Si il possède un bagage
            {
                if(p->luggages[0] != NULL && p->luggages[0]->boarded == 0) //Si le bagage n'est pas chargé
                {
                    int charger;
                    do {
                        printf("Charger le bagage #%d de %s %s qui pese %fkg :", p->luggages[0]->ticket, p->first_name, p->last_name, p->luggages[0]->weight);
                        scanf("%d", &charger);
                    } while(charger < 0 || charger > 1);

                    if(charger == 1) //Il faut charger le bagage
                    {
                        p->luggages[0]->boarded = 1; //Le bagage est chargé
                        p->flight->luggages_weight += p->luggages[0]->weight; //L'avion est plus lourd
                    }
                }
            }
        }
    }
}

void flight_take_off()
{ //On va (enfin ??!) pouvoir décoller
    printf("Affichage des vols.\n");
    show_flights();

    int flight_id;
    printf("Veuillez entrer l'ID du vol qui est sur le point de decoller : ");
    do {
        scanf("%d", &flight_id);
        if(flight_id > flights_length-1 || flight_id < 0) printf("Ce vol n'existe pas. Veuillez entrer l'ID du vol.\n");
        else if(flights[flight_id]->took_off == 1) printf("Ce vol a deja decolle ! Annulation.\n");
    } while(flight_id > flights_length-1 || flight_id < 0);

    printf("Verification que tous les passagers ont embarque et que tous leurs bagages sont charges.\n");
    struct Flight *f = flights[flight_id]; //Vol à faire décoller
    struct Passenger **registered_passengers = get_registered_passengers_on_flight(flight_id); int registered_passengers_count = f->registered_passengers_count; //Passagers à faire décoller (dans l'avion...)
    int i;
    for(i=0;i<registered_passengers_count;i++)
    {
        if(registered_passengers[i]->etape < 4) //Si un des passagers enregistré n'est pas à l'étape 4 qui correspond à l'embarquement, l'avion ne peut pas décoller
        {
            printf("Tous les passagers n'ont pas encore embarque ! Veuillez proceder a l'embarquement de tous les passagers avant de continuer.\n");
            return;
        }

        for(int j=0;j<2;j++) //Pour chaque bagage
        {
            if(registered_passengers[i]->luggages[j] != NULL && registered_passengers[i]->luggages[j]->boarded == 0) //Si le bagage existe, et s'il n'est pas chargé, l'avion ne peut pas décoller
            {
                printf("Tous les bagages n'ont pas encore ete charges ! Veuillez proceder au chargement de tous les bagages avant de continuer.\n");
                return;
            }
        }
    }

    //On est arrivés jusque là ! Cela signifie que tout va bien, l'avion peut décoller.

    printf("Tous les passagers et tous leurs bagages ont ete embarques. Le vol va desormais decoller.\n");
    for(i=0;i<registered_passengers_count;i++)
    {
        registered_passengers[i]->etape++; //Tous les passagers sont désomais en vol
    }

    f->took_off = 1; //Félicitations, l'avion est parvenu à décoller !
}

struct Passenger* find_passenger(char* name, int ticket) //On trouve un passager en fonction de son nom ou de son billet
{
    if(ticket != -1) //Si on trouve le passager en fonction de son billet
    {
        int found = 0; //On ne l'a pas encore trouvé

        for(i=0;i<passengers_length;i++) //Pour chaque passager
        {
            if(passengers[i]->ticket == ticket) //Le billet du passager est le même que celui demandé !
            {
                found = 1; //On a donc trouvé le passager
                break; //On peut y aller
            }
        }

        if(found != 1) //Ohoh... Nous ne sommes pas parvenus à trouver un passager avec ce billet
        {
            printf("Desole, le passager avec le ticket #%d n'a pas ete trouve.\n", ticket);
            return NULL; //On renvoie NULL afin de gérer le cas dans les autres fonctions
        }
        else //On a trouvé le passager
        {
            return passengers[i]; //On renvoie un pointeur vers le passager demandé
        }
    }
    else //On cherche le passager en fonction de son nom
    {
        struct Passenger** occ; //Il se peut que plusieurs passagers aient le même nom, donc on prévoit un tableau pour tous les accueillir
        int occ_size = 0, lastPos; //La taille du tableau et la position du passager à renvoyer si plusieurs portent le même nom

        occ = (struct Passenger**) malloc(sizeof(struct Passenger*)); //On a une place


        for(i=0;i<passengers_length;i++) //Pour chaque passager existant
        {
            if(strcmp(name, passengers[i]->last_name) == 0) //Si le nom est le même que celui demandé
            {
                occ = (struct Passenger**) realloc(occ, sizeof(occ) + sizeof(struct Passenger*));
                occ[occ_size] = passengers[i];
                occ_size++; //On ajoute le passager au tableau des passagers avec le nom demandé
                lastPos = i; //On se remémore la position de la dernière occurence dans le tableau des passagers
            }
        }

        if(occ_size == 0) //Si le tableau est vide
        {
            printf("Aucun passager avec ce nom n'a ete trouve.\n");
            return NULL; //On a pas trouvé
        }
        else if(occ_size == 1) //Si un seul passager a été trouvé
        {
            return passengers[lastPos]; //On renvoie un pointeur
        }
        else //On en a trouvé plus d'un
        {
            printf("Plusieurs passagers avec ce nom ont ete trouves.\n");

            for(i=0;i<occ_size;i++)
            {
                printf("%d - %s %s\n", i, occ[i]->last_name, occ[i]->first_name); //On affiche tous les passagers avec ce nom
            }

            do {
                printf("Entrer le numero de la personne a choisir.\n");
                scanf("%d", &lastPos); getchar(); //On demande à l'utilisateur de choisir le passager
            } while(lastPos < 0 || lastPos > occ_size-1);

            return occ[lastPos]; //Et on renvoie un pointeur vers ce passager
        }
    }
}

struct Passenger** get_registered_passengers_on_flight(int id) //Renvoie tous les passagers enregistrés sur un vol demandé
{
    int i, counter = 0;
    struct Passenger** registered_passengers;
    for(i=0;i<passengers_length;i++) //Pour chaque passager existant
    {
        if(passengers[i]->etape >= 1 && passengers[i]->flight == flights[id]) //Si le passager est enregistré et que le vol est le même que celui demandé
        {
            if(counter == 0) //Si c'est le premier passager trouvé
            {
                registered_passengers = (struct Passenger**) malloc(sizeof(struct Passenger*)); //On alloue pour la première de la mémoire pour renvoyer nos pointeurs
            }
            else
            {
                registered_passengers = (struct Passenger**) realloc(registered_passengers, sizeof(registered_passengers) + sizeof(struct Passenger*)); //On réalloue la mémoire à chaque nouveau passager
            }

            registered_passengers[counter] = passengers[i]; //On affecte le nouveau passager au tableau des passagers enregistrés sur le vol
            counter++;
            if(counter == flights[id]->registered_passengers_count) break; //Si on a trouvé autant de passagers enregistrés qu'il y en a sur le vol, on peut s'arrêter (et gagner quelques millisecondes !)
        }
    }

    return registered_passengers; //On renvoie les pointeurs vers les passagers enregistrés
}

char* input_string() //Fonction faite main pour affecter directement une entrée utilisateur à un pointeur char
{
    int n = 0;
    char *c = (char*) malloc(1);
    char saisie = getchar();
    while(saisie != '\n')
    {
        c[n] = saisie;
        saisie = getchar();
        n++;
        c = (char*) realloc(c, n+1);
    }

    c[n] = '\0';

    return c;
}