##################################fichier.

c########################################
############
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>
#include <time.h>
#include <math.h>
#include "gestion.h"
#define DELAI 5

void consulter_historique(Liste_compagnie *liste,Liste_avion sl)

{
Cellule_compagnie* courant = *liste;
while (courant != NULL)
{
printf("Compagnie: %s\n", courant->comp.nom);
// Parcours la liste
Cellule_avion* avion_courant = sl;

while (avion_courant != NULL)

{
printf("avion: %s\n", avion_courant->avion.identifiant);
printf("Carburant: %d\n", avion_courant->avion.carburant);
printf("Consommation: %d\n", avion_courant->avion.consommation);
printf("Heure_decollage: %s\n", avion_courant->avion.heure_decollage);
avion_courant = avion_courant->compagnie_suivant;
}
courant = courant->suivant;
}
}

void liste_noire_compagnie(Liste_compagnie* liste, Compagnie compagnie)

{
Cellule_compagnie* nouv_cellule =
(Cellule_compagnie*)malloc(sizeof(Cellule_compagnie));
nouv_cellule->comp = compagnie;
nouv_cellule->suivant = NULL;

if (*liste == NULL)
{
*liste = nouv_cellule;
}
else
{
Cellule_compagnie* courant = *liste;
while (courant->suivant != NULL)
{
courant = courant->suivant;
}
courant->suivant = nouv_cellule;
}
}

void Liste_avion_attent_atter(Cellule_avion **sl,Avion av)

{
 Cellule_avion *tmp = NULL;
Cellule_avion *csl = *sl;
Cellule_avion *elem = (Cellule_avion*)malloc(sizeof(Cellule_avion));
if(!elem) exit(1);
elem->avion = av;

while(csl && (av.carburant - av.consommation) >= 0.05*av.carburant)

{
tmp = csl;
csl = csl->suivant_attente;
}
elem->suivant_attente = csl;
if(tmp) tmp->suivant_attente = elem;
else *sl = elem;
}

void priorite_atterrissage(Liste_avion liste, char identifiant[])

{
// Parcourir la liste et déplacer l'avion avec l'identifiant donné en tête de
liste
Cellule_avion* courant = liste;
Cellule_avion* precedent = NULL ;
while (courant != NULL )
{
if ( strcmp (courant->avion.identifiant, identifiant) == 0 )
{
if (precedent == NULL )
{
// L'avion est déjà en tête de la liste
break ;
}
else
{
precedent->suivant_attente = courant->suivant_attente;
courant->suivant_attente = liste;
liste = courant;
break;
}
}
precedent = courant;
courant = courant->suivant_attente;
}
}

void stocker_liste_avion(Cellule_compagnie *liste)

{
FILE *fp;
fp = fopen("aeroport.log", "w");
Cellule_compagnie *courant = liste;
while(courant!=NULL)
{
fprintf(fp, "Compagnie: \n", courant->comp.nom);
Cellule_avion* avion_courant = courant->comp.avion_compagnie;
while(avion_courant!=NULL)
{
fprintf(fp, "\tavion: %s\n", avion_courant->avion.identifiant);
avion_courant = avion_courant->compagnie_suivant;
}
 courant = courant->suivant;
}
fclose(fp);
}

void Ajout_avion(Liste_avion* tete, Avion avion)

{
// Allouer la memoire pour le nouvel avion
Cellule_avion* new_avion = (Cellule_avion*)malloc(sizeof(Cellule_avion));
new_avion->avion = avion;
new_avion->compagnie_suivant = NULL;
new_avion->compagnie_precedent = NULL;
new_avion->suivant_attente = NULL;

// Si la liste est vide on met l'avion en debut de liste

if (*tete == NULL) {
*tete = new_avion;
}

else {
Cellule_avion* courant = *tete;
while (courant->compagnie_suivant != NULL)
{
courant = courant->compagnie_suivant;
}
courant->compagnie_suivant = new_avion;
new_avion->compagnie_precedent = courant;
}
}

void Ajout_compagnie(Cellule_compagnie** tete, Compagnie compagnie)

{
// Allouer une memoire pour la compagnie
Cellule_compagnie* new_compagnie =
(Cellule_compagnie*)malloc(sizeof(Cellule_compagnie));
new_compagnie->comp = compagnie;
new_compagnie->suivant = NULL;

if (*tete == NULL) {
*tete = new_compagnie;
}

else {
Cellule_compagnie* courant = *tete;
while (courant->suivant != NULL) {
courant = courant->suivant;
}
courant->suivant = new_compagnie;
}
}

// Supprime la fonction de la liste

void Supprimer_avion(Liste_avion* tete, char* id)
{
// Si la liste est vide
if (*tete == NULL)
{
 return;
}

Cellule_avion* courant = *tete;

if (strcmp(courant->avion.identifiant, id) == 0)
{
*tete = courant->compagnie_suivant;
if (*tete != NULL)
{
(*tete)->compagnie_precedent = NULL;
}
free(courant);
return;
}

// parcours la liste
while (courant != NULL && strcmp(courant->avion.identifiant, id) != 0)
{
courant = courant->compagnie_suivant;
}

// si l'aeronef a supprimer n'est pas trouver

if (courant == NULL)
{
return;
}

// Suppression de la liste
courant->compagnie_precedent->compagnie_suivant = courant->compagnie_suivant;
if (courant->compagnie_suivant != NULL)
{
courant->compagnie_suivant->compagnie_precedent = courant-
>compagnie_precedent;
}
free(courant);
}

void Affiche_liste_avion(Liste_avion tete)

{
// Si la liste est vide
if (tete == NULL)
{
printf("Pas d'avion dans la liste.\n");
return;
}
Cellule_avion* courant = tete;
while (courant != NULL)
{
color(3,0);
printf("Identifiant: %s\n", courant->avion.identifiant);
printf("Carburant: %d\n", courant->avion.carburant);
printf("Consommation: %d\n", courant->avion.consommation);
printf("Heure_decollage: %s\n", courant->avion.heure_decollage);
printf("Compagnie: %s\n", courant->avion.compagnie->nom);
printf("\n");
courant = courant->compagnie_suivant;
}
}

int* get_local_time_plus_five_minutes()
{
time_t t = time(NULL);
struct tm *tm = localtime(&t);
int hour = tm->tm_hour;
int minute = tm->tm_min + 5;
if (minute >= 60)
{
hour++;
minute -= 60;
}
int *time = (int*)malloc(2*sizeof(int));
time[0] = hour;
time[1] = minute;
return time;
}

void demande_statut(Liste_compagnie *liste, char* compagnie_acronyme)

{
char *time;
Cellule_compagnie* courant = *liste;

while (courant != NULL)

{
if (strcmp(courant->comp.acronyme, compagnie_acronyme) == 0)
{

Cellule_avion* avion_courant = courant->comp.avion_compagnie;

int num_atterrissage = 1;
int num_decollage = 0;
time=(char*)get_local_time_plus_five_minutes();
while (avion_courant != NULL)
{

if (avion_courant->avion.heure_decollage != NULL)
{
num_decollage = num_decollage + 1;
}
else if (avion_courant->suivant_attente != NULL)
{
num_atterrissage = num_atterrissage + 1;

}
avion_courant = avion_courant->compagnie_suivant;
}
printf("Nombre d'avion au decollage: %d\n", num_decollage);
printf("Nombre d'avion a l'atterrissage: %d\n", num_atterrissage);
}
courant = courant->suivant;
}
}

void color(int t, int f)

{
 HANDLE H =GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute(H,f*16+t);
}
int codage_events(char events[], FILE *aeroport_log)
{
char id[7];
char statut;
char H_D[5];
char carb_rest[3];
char conso[3];

sscanf(events, "%6s-%c-%4s-%2s-%2s", id, &statut, H_D, carb_rest, conso);

if (strcmp(id, "") == 0)
{
printf("Veuillez entrer le nom de la compagnie: ");
scanf("%s", id);
}

switch (statut)
{
case 'A':
fprintf(aeroport_log, "%s-a-%s-%s-%s\n", id, &statut, H_D, carb_rest,
conso);
break;
case 'U':
fprintf(aeroport_log, "%s-u-%s-%s-%s\n", id, &statut, H_D, carb_rest,
conso);
break;
case 'N':
fprintf(aeroport_log, "%s-n-%s-%s-%s\n", id, &statut, H_D, carb_rest,
conso);
break;
case 'D':
fprintf(aeroport_log, "%s-d-%s-%s-%s\n",id, &statut, H_D, carb_rest,
conso);
break;
case 'C':
fprintf(aeroport_log, "%s-c-%s-%s-%s\n",id, &statut, H_D, carb_rest,
conso);
break;
default:
printf("Statut Indique Invalide\n");
return -1;
}

return 0;
}

######################################Fichier.h####################################
#########################
#ifndef _FILE_H
#define _FILE_H

// Define the structure for a plane

typedef struct avion
 {
char identifiant[7];
int carburant;
int consommation;
char heure_decollage[4];
struct compagnie* compagnie;
} Avion;

// Define the structure for a company

typedef struct compagnie
{
char* nom;
char acronyme[3];
struct cellule_avion* avion_compagnie;
} Compagnie;

// Define the structure for a company cell

typedef struct cellule_compagnie {
Compagnie comp;
struct cellule_compagnie* suivant;
} Cellule_compagnie;

// Define the structure for a plane cell

typedef struct cellule_avion
{
Avion avion;
struct cellule_avion* compagnie_suivant;
struct cellule_avion* compagnie_precedent;
struct cellule_avion* suivant_attente;
} Cellule_avion;

// Define the structure for a queue

typedef struct queue
{
Cellule_avion* premier;
Cellule_avion* dernier;
} Queue;

// Definition de types
typedef Cellule_avion* Liste_avion;
typedef Cellule_compagnie *Liste_compagnie;

//VARIABLES GLOBALES

Liste_compagnie *compagnies;
Liste_avion *avions;

// PROTOTYPES DE FONCTIONS
int* get_local_time_plus_five_minutes();
void Ajout_avion(Liste_avion*, Avion) ;
void Ajout_compagnie(Cellule_compagnie**, Compagnie);
void Supprimer_avion(Liste_avion*, char*);
void Affiche_liste_avion(Liste_avion);
void color(int , int );
int codage_events(char [], FILE *);
void stocker_liste_avion(Cellule_compagnie *);
void Liste_avion_attent_atter(Cellule_avion **, Avion);
void priorite_atterrissage(Liste_avion, char []);
void demande_statut(Liste_compagnie *, char*);
void consulter_historique(Liste_compagnie *,Liste_avion);
void liste_noire_compagnie(Liste_compagnie* , Compagnie);
#endif

#########################################main.c####################################
###############"""

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>
#include "gestion.h"

int main()
{

// Initialisation de la liste des aéronefs et celle des compagnies aériennes

Liste_avion liste_avion = NULL;
Cellule_compagnie* liste_compagnie = NULL;
Liste_avion decollage = NULL;
Liste_avion atterrissage = NULL;
Liste_compagnie compagnies= NULL;
Compagnie comp;
Avion avion;
int choice = 0;
int add_another = 1;
FILE *aeroport_log = NULL;
char events[19],id[7],h_d[5],etat[2],acronyme[4],name;
int carb, cons;

color(10,0);
printf("\t\t\t++++++++++++++++++++++++++++++++++++++++++++++++++++++\n\t\t\t
GESTION DU TRAFIC AERIEN D'UN AEROPORT \n\t\t\t++++++++++++++++++++++++++++++++++
++++++++++++++++++++\n\n");
while(choice != 10)
{
color(15,0);
printf( "\t\t\t\t Veuillez faire votre choix en tapant:\n\n 1 Pour ajouter un
avion au decollage ou a l'atterrissage:\n\n 2 Pour afficher la liste des avions au
decollage:\n\n 3 Pour supprimer un avion au decollage:\n\n 4 Pour decider qu'un
avion en attente devienne proritaire \n\n 5 Pour mettre une compagnie sur la liste
noire\n\n 6 Pour afficher la liste des attentes d'atterrissage\n\n 7 Pour demander
le statut de tous les avions d'une compagnie donnee\n\n 8 Pour consulter
l'historique\n\n 9 Pour le codage des evenements:\n\n 10 pour sortir:\n");
scanf("%d", &choice);
switch (choice)
{
case 1:
while (add_another)
{
// Details des informations sur le nouveau avion

char etat[2];
Avion new_avion;
color(2,0);
printf("Entrer l'identifiant de l'aeronef (6 caracteres):");
scanf("%s", new_avion.identifiant);
 printf("Entrer la quantite de carburant(en litre): ");
scanf("%d", &new_avion.carburant);
printf("Entrer la consommation de carburant(en litre): ");
scanf("%d", &new_avion.consommation);
printf("Entrer l'heure de decollage (4 caracteres): ");
scanf("%s", new_avion.heure_decollage);

// Create a new company if necessary

char compagnie_acronyme[4];
strncpy(compagnie_acronyme, new_avion.identifiant, 3);
compagnie_acronyme[3] = '\0';
Compagnie* compagnie = NULL;
Cellule_compagnie* courant = liste_compagnie;
while (courant != NULL)
{
if (strcmp(courant->comp.acronyme, compagnie_acronyme) == 0)
{
compagnie = &(courant->comp);
break;
}
courant = courant->suivant;
}
if (compagnie == NULL)
{
compagnie = (Compagnie*)malloc(sizeof(Compagnie));
compagnie->nom = (char*)malloc(sizeof(char)*50);
printf("Entrer le nom de la compagnie : ");
scanf("%s", compagnie->nom);
strncpy(compagnie->acronyme, compagnie_acronyme, 3);
compagnie->acronyme[3] = '\0';
compagnie->avion_compagnie = NULL;
Ajout_compagnie(&liste_compagnie, *compagnie);

printf("Entrer l'etat de l'avion (A,U,N,D):");

scanf("%s",etat);
if(etat[0]=='D')
{
// Ajout d'un nouveau aeronef dans la liste
new_avion.compagnie = compagnie;
Ajout_avion(&liste_avion, new_avion);
Ajout_avion(&decollage, new_avion);
// Demande à l'utilisateur s'il veut ajouter un autre aeronef
}
else if(etat[0]=='A')
{
// Ajout d'un nouveau aeronef dans la liste
new_avion.compagnie = compagnie;
Ajout_avion(&liste_avion, new_avion);
Ajout_avion(&atterrissage, new_avion);
// Demande à l'utilisateur s'il veut ajouter un autre aeronef
}
else if(etat[0]=='U')
{
// Ajout d'un nouveau aeronef dans la liste
new_avion.compagnie = compagnie;
Ajout_avion(&liste_avion, new_avion);
priorite_atterrissage(atterrissage,new_avion.identifiant);
 Ajout_avion(&atterrissage, new_avion);
// Demande à l'utilisateur s'il veut ajouter un autre aeronef
}
else if(etat[0]=='N')
{
// Ajout d'un nouveau aeronef dans la liste
new_avion.compagnie = compagnie;
Ajout_avion(&liste_avion, new_avion);
Ajout_avion(&atterrissage, new_avion);
}

printf("Ajout d'un autre aeronef? (0 for no, 1 for yes): ");

scanf("%d", &add_another);
}
break;
case 2:
// Afficher la liste des avions au decollage
Affiche_liste_avion(decollage);
break;
case 3:
// Supprimer un aeronef de la liste
printf("Entrer l'identifiant de l'aeronef a supprimer: ");
scanf("%s", id);
Supprimer_avion(&decollage, id);
break;
case 4:
printf("Entrer l'identifiant de l'avion prioritaire: ");
scanf("%s", id);
priorite_atterrissage(atterrissage,id);
break;
case 5:
printf("ENTRER L'ACRONYME DE LA COMPAGNIE AERIENNE:\n");
scanf("%s",acronyme);
strcpy(comp.acronyme, acronyme);
liste_noire_compagnie(&liste_compagnie , comp);
printf ( "Compagnie %s ajoutee a la liste noire.\n" ,
comp.acronyme);
break;
case 6:
printf("La liste des attentes d'atterrissage est:\n");
Affiche_liste_avion(atterrissage);

break;
case 7:
printf("ENTRER L'ACRONYME DE LA COMPAGNIE AERIENNE:");
scanf("%s",acronyme);
demande_statut(&liste_compagnie,acronyme);
break;
case 8:
consulter_historique(&liste_compagnie,liste_avion);
break;
case 9:
aeroport_log = fopen("aeroport.log", "w");
if (aeroport_log == NULL)
{
printf("ERREUR D'OUVERTURE DU FICHIER!\n");
exit(1);
}
 //Ajout de trois evenements
aeroport_log = fopen("aeroport.log", "w");
if (aeroport_log == NULL)
{
printf("Erreur d'ouverture du fichier!\n");
exit(1);
}

// Add the following 3 events

strcpy(events, "DLA043-D-1143------");
codage_events(events, aeroport_log);

strcpy(events, "NWA050-A------05-02");
codage_events(events, aeroport_log);

strcpy(events, "ALI122-U------02-01");
codage_events(events, aeroport_log);

// Avion sorti de la liste d'attente

strcpy(events, "TKC059-c-1250------");
codage_events(events, aeroport_log);

fclose(aeroport_log);

break;
case 10:
color(6,0);
printf ("++++++++++++++++++++++++++++++++++MERCI ET A BIENTOT++++
++++++++++++++++++++++++++++++") ;
break;
default:
break;
}

}
return 0;
}