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

/* Med: On déclare généralement les structures en global. */
//DECLARATION DES TYPES DE STRUCTURES
typedef struct piste
{
	int code_piste, nb_empl;
	char designation[20], statut[20], type_vol[20];
}piste;

typedef struct employe
{
	int code_employe, code_piste,nb_empl;
	char nom[15], prenom[15], tel[11], fonction[20];
	/* Med: Champ inutile dont je ne m'explique pas la présence. piste element; */
}employe;

//Macro ARRAYSIZE(), qui donne toujours la longueur d'un tableau.
//A ne pas utiliser sur les pointeurs.
#ifndef ARRAYSIZE
#define ARRAYSIZE(tab) (sizeof(tab)/sizeof(tab[0]))
#endif


/*===========================================================================*/

/* Med : Cette fonction ressemble sûrement à une formule magique, 
   mais elle sert à vider une ligne dans l'entrée. */
int ViderLigne(void)
{
	int retour = 0;
	int c;
	while((c=getchar()) != EOF && c != '\n')
	{
	}

	if(c==EOF)
		retour = -1; /* Il n'y a plus rien en entrée */

	return retour;
}
/*---------------------------------------------------------------------------*/
/* Med: Une fonction assez sûre pour demander un entier.
  Retourne def en cas d'échec. */
int DemanderNombre(char const *message, int def)
{
	int choix = def;
	int nScanned;
	int resViderLigne = 0; /* 0 = Une valeur qui ne fait pas quitter la boucle. */
	
	/* Med: Une boucle do-while qui pose la question jusqu'à ce qu'une réponse valide soit donnée. */
	do
	{
		printf(message);
		/* Med : Après un printf() sans retour à la ligne, un fflush() est nécessaire */
		fflush(stdout);

		nScanned = scanf("%d", &choix);
		resViderLigne = ViderLigne();
	} while(nScanned != 1 && resViderLigne >= 0);
	
	if(nScanned != 1 && resViderLigne < 0)
	{
		/* Echec de scanf(), et plus rien en entrée: Retourner def */
		choix = def;
	}

	return choix;
}
/*---------------------------------------------------------------------------*/
/* Med: Une fonction assez sûre pour demander une chaîne.
   Retourne -1 en cas d'échec, la longueur de la chaîne sinon.
   Note: 
   taille est un int au lieu d'un size_t, parce que la fonction fgets() prend un int. */
int DemanderChaine(char const *message, char *buffer, int taille)
{
	int retour = 0;

	printf(message);
	/* Med : Après un printf() sans retour à la ligne, un fflush() est nécessaire */
	fflush(stdout);

	if(fgets(buffer, taille, stdin)==NULL)
	{
		//Erreur de saisie, plus rien en entrée : retourner -1
		retour = -1;
	}
	else
	{
		//Traiter la saisie: Il y a forcément un \n de tapé, mais il est soit dans la chaîne,
		//soit toujours dans la console.
		char *pLF = strchr(buffer, '\n');
		if(pLF != NULL)
		{
			//Supprimer le \n dans la chaîne, calculer la longueur.
			*pLF = '\0';
			retour = (int)(pLF-buffer);
		}
		else
		{
			//Le \n est toujours dans la console, la chaîne saisie a la longueur maximale.
			ViderLigne();
			retour = taille-1;
		}
	}
	return retour;
}
/*---------------------------------------------------------------------------*/
int ChoixMenuPrincipal(void)
{
	system("cls");
	puts("\n\t\t°°°°°°°°° Menu principal°°°°°°°°°");
	puts("\t\t°                               °");               
	puts("\t\t° 1. Gestion des pistes         °");
	puts("\t\t° 2. Gestion des employes       °");
	puts("\t\t° 3. Statistiques               °");
	puts("\t\t° 0. Quitter                    °");
	puts("\t\t°                               °"); 
	puts("\t\t°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°\n");                 

	return DemanderNombre("\t\tVotre choix : ", 0);
}
/*---------------------------------------------------------------------------*/
int ChoixMenuPiste(void)
{
	system("cls");
	puts("______________Gestions des pistes______________\n");
	puts(" 1. Ajouter une piste");
	puts(" 2. Consulter une piste");
	puts(" 3. Modifier une piste");
	puts(" 4. Supprimer une piste");
	puts(" 5. Afficher les employes d'une piste");
	puts(" 6. Trier les pistes par nombre d'employes");
	puts(" 7. Trier les pistes par type de vol");
	puts(" 8. Trier les pistes par statut");
	puts(" 9. Reaffecter l'employe d'une piste a une autre");
	puts(" 0. Quitter");
	return DemanderNombre("Choix : ", 0);
}
/*---------------------------------------------------------------------------*/
int ChoixMenuEmploye(void)
{
	system("cls");
	puts("______________Gestions des employes______________\n");
	puts(" 1. Ajouter un employe");
	puts(" 2. Consulter un employe");
	puts(" 3. Modifier un employe");
	puts(" 4. Supprimer un employe");
	puts(" 5. Trier les employes par numero de piste");
	puts(" X. Trier les employes de l'international");
	puts(" X. Trier les employes de la nationale");
	puts(" 8. Trier les employes par fonction");
	puts(" 9. Verifier les doublons");
	puts(" 0. Quitter");
	return DemanderNombre("Choix : ", 0);
}
/*---------------------------------------------------------------------------*/
int ChoixMenuStatistiques(void)
{
	system("cls");
	puts("_________________________Statistiques_________________________\n");
	puts(" 1. Les pistes par nombre d'employes");
	puts(" 2. Les pistes qui ont un minimum et un maximum d'employes");
	puts(" 3. Nombre moyen d'employes par piste");
	puts(" 4. Nombre d'employe par statut");
	puts(" 5. Nombre d'employes par type de vol");
	puts(" 6. Nombre d'employes par fonction");
	puts(" 0. Quitter");
	return DemanderNombre("Choix : ", 0);
}
/*---------------------------------------------------------------------------*/
/* Retourne l'index de la piste dans un tableau de nPistes pistes.
   Retourne une valeur de 0 à nPistes-1 si trouvé, nPistes en cas d'échec. */
size_t TrouverPiste(piste const * pcPistes, size_t nPistes, int code)
{
	size_t iPiste;
	
	for(iPiste=0 ; iPiste<nPistes ; iPiste++)
	{
		/* On utilise break pour sortir de la boucle sans incrémenter iPiste */
		if(pcPistes[iPiste].code_piste == code)
			break;
	}
	return iPiste;
}
/*---------------------------------------------------------------------------*/
/* Retourne l'index de l'employé dans un tableau de nEmployes employés.
   Retourne une valeur de 0 à nEmployes-1 si trouvé, nEmployes en cas d'échec. */
size_t TrouverEmploye(employe const * pcEmployes, size_t nEmployes, int code)
{
	size_t iEmpl;
	int bTrouve = 0;
	
	for(iEmpl=0 ; iEmpl<nEmployes && !bTrouve ; iEmpl++)
	{
		/* On utilise break pour sortir de la boucle sans incrémenter iEmpl */
		if(pcEmployes[iEmpl].code_employe == code)
			break;
	}
	return iEmpl;
}

/*---------------------------------------------------------------------------*/
/* Comptage des employés de chaque piste */
void CompterEmployesPistes(piste * tab_piste, size_t nb_piste, employe const * tab_employe, size_t nb_employe)
{
	size_t iPiste;
	for(iPiste=0 ; iPiste<nb_piste ; iPiste++)
	{
		size_t iEmpl;
		
		//INITIALISATION DU nb_empl A 0
		tab_piste[iPiste].nb_empl=0;

		for(iEmpl=0 ; iEmpl<nb_employe ; iEmpl++)
		{
			if(tab_piste[iPiste].code_piste==tab_employe[iEmpl].code_piste)
				tab_piste[iPiste].nb_empl++;
		}
	}
}
/*---------------------------------------------------------------------------*/
/* Tri des pistes.
   Med: Cette fonction de tri semble OK. C'est le code de celle-ci qu'on va utiliser à l'avenir. */
void TrierPistesNbEmployes(piste * tab_piste, size_t nb_piste)
{
	if(nb_piste > 0)
	{
		size_t iPiste;
		for(iPiste=0 ; iPiste<nb_piste-1 ; iPiste++)
		{
			size_t iAutrePiste;
			for(iAutrePiste=iPiste+1 ; iAutrePiste<nb_piste ; iAutrePiste++)
			{
				/* Tri décroissant: On permute si le premier est supérieur au second. */
				if(tab_piste[iPiste].nb_empl < tab_piste[iAutrePiste].nb_empl)
				{
					/* Echange */
					piste tempPiste = tab_piste[iPiste];
					tab_piste[iPiste] = tab_piste[iAutrePiste];
					tab_piste[iAutrePiste] = tempPiste;
				}
			}
		}
	}
}
/*---------------------------------------------------------------------------*/
void ModifierPiste(piste *pPiste)
{
	int choix_m;
	do
	{
		printf(" 1. Modifier le statut\n");
		printf(" 2. Modifier la designation\n");
		printf(" 3. Modifier le type de vol\n");
		printf(" 0. Quitter\n");
		choix_m = DemanderNombre("Choix : ", 0);
		switch(choix_m)
		{
		case 1:
			{
			system("cls");
			DemanderChaine("Donner le nouveau statut\n", pPiste->statut, ARRAYSIZE(pPiste->statut));
			}
			break;

		case 2:
			{
			system("cls");
			DemanderChaine("Donner la nouvelle designation\n", pPiste->designation, ARRAYSIZE(pPiste->designation));
			}
			break;

		case 3:
			{
			system("cls");
			DemanderChaine("Donner le nouveau type de vol\n", pPiste->type_vol, ARRAYSIZE(pPiste->type_vol));
			}
			break;

		default:
			printf("Erreur de saisie\n");	
		}
	} while(choix_m!=0);
}
/*---------------------------------------------------------------------------*/
void GestionDesPistes(piste * tab_piste, size_t *pNPistes, size_t maxPistes, employe * tab_employe, size_t *pNEmployes)
{
	size_t nb_piste = *pNPistes;
	size_t nb_employe = *pNEmployes;
	
	int choix_p;
	do
	{
		choix_p = ChoixMenuPiste();

		switch(choix_p)
		{
		case 1:	// AJOUT D'UNE PISTE
			{
			system("cls");
			if(nb_piste >= maxPistes)
				printf("Nb max de pistes (%d) atteint.\n", (int)maxPistes);
			else
			{
				printf("Vous allez saisir une piste\n");
				tab_piste[nb_piste].code_piste = DemanderNombre("Saisir le code piste\n", -1);
				DemanderChaine("Saisir un statut\n", tab_piste[nb_piste].statut, ARRAYSIZE(tab_piste[nb_piste].statut));
				DemanderChaine("Saisir une designation\n", tab_piste[nb_piste].designation, ARRAYSIZE(tab_piste[nb_piste].designation));
				DemanderChaine("Saisir un type de vol\n", tab_piste[nb_piste].type_vol, ARRAYSIZE(tab_piste[nb_piste].type_vol));
				nb_piste++;
				printf("\nIl y a maintenant %d pistes\n\n", (int)nb_piste);
			}
			system("pause");
			}
			break;

		case 2: // CONSULTER UNE PISTE
			{
			/* Med: On peut déclarer une variable au début de n'importe quel bloc. */
			size_t iPiste=0;
			int codePisteVoulue;

			system("cls");
			codePisteVoulue = DemanderNombre("Quel code piste souhaitez vous consulter?\n", 0);
			iPiste = TrouverPiste(tab_piste, nb_piste, codePisteVoulue);

			if(iPiste < nb_piste)
			{
				printf("Les renseignements sur la piste %d sont:\n", codePisteVoulue);
				printf("son nom : %s\n",tab_piste[iPiste].designation);
				printf("son statut : %s\n",tab_piste[iPiste].statut);
				printf("et de type vol : %s\n\n",tab_piste[iPiste].type_vol);
				system("pause");
			}
			else
				printf("Erreur de saisie");
			}
			break;

		case 3:	//MODIFIER UNE PISTE
			{
			size_t iPiste=0;
			int codePisteVoulue;

			system("cls");
			codePisteVoulue = DemanderNombre("Donner le code de la piste a modifier\n", 0);
			iPiste = TrouverPiste(tab_piste, nb_piste, codePisteVoulue);

			if(iPiste < nb_piste)
				ModifierPiste(&tab_piste[iPiste]);
			else
				printf("Erreur de saisie\n");
			}
			break;

		case 4:	//SUPPRIMER UNE PISTE
			{
			size_t iPiste=0;
			int codePisteVoulue;

			system("cls");
			codePisteVoulue = DemanderNombre("Donner le code de la piste a supprimer\n", 0);
			iPiste = TrouverPiste(tab_piste, nb_piste, codePisteVoulue);

			/* Supprime la piste et met la dernière à la place pour ne pas laisser de trou */
			if(iPiste < nb_piste)
			{
				/* Med: Il faut diminuer le nombre total AVANT la copie,
				   sinon on copie une piste qui n'existe pas. */
				nb_piste--;
				tab_piste[iPiste] = tab_piste[nb_piste];
				
				printf("Il reste donc: %d pistes\n", (int)nb_piste);
				system("pause");
			}
			else
				printf("Erreur de saisie\n");
			}
			break;

		case 5:	//AFFICHER LES EMPLOYES D'UNE PISTE
			{
			size_t iEmpl=0;
			int codePisteVoulue;

			system("cls");
			codePisteVoulue = DemanderNombre("Quel est le code piste utilise pour la recherche du nombre d'employe?\n", 0);

			// POUR LES BOUCLES PAS DE <= CAR ON COMMENCE A i=0
			printf("\nConcernant le code piste:%d, les employes sont:\n", codePisteVoulue);
			for(iEmpl=0 ; iEmpl<nb_employe ; iEmpl++)
			{
				if(codePisteVoulue==tab_employe[iEmpl].code_piste)
				{
					printf("Code employe:%d\n", tab_employe[iEmpl].code_employe);
					printf("Nom:%s\n", tab_employe[iEmpl].nom);
					printf("Prenom:%s\n", tab_employe[iEmpl].prenom);
					printf("Tel:%s\n", tab_employe[iEmpl].tel);
				}
			}
			system("pause");
			}
			break;

		case 6:	//TRIER LES PISTES PAR NOMBRE D'EMPLOYES
			{
			size_t iPiste;
			system("cls");
			
			/* Comptage des employés de chaque piste */
			CompterEmployesPistes(tab_piste, nb_piste, tab_employe, nb_employe);

			/* Tri des pistes.
			   Med: Cette fonction de tri semble OK. C'est celle-ci qu'on va utiliser à l'avenir. */
			TrierPistesNbEmployes(tab_piste, nb_piste);
				
			printf("Les pistes triees par nombre d'employes sont:\n");
			for(iPiste=0 ; iPiste<nb_piste ; iPiste++)
			{
				printf("\nCode piste:%d\n", tab_piste[iPiste].code_piste);
				printf("Nombre d'employe:%d\n", tab_piste[iPiste].nb_empl);
			}
			system("pause");
			}
			break;

		case 7:	//TRIER LES PISTES PAR TYPE DE VOL
			{
			size_t iPiste;
			
			system("cls");
			/* Med: Ici, on vérifie que nb_piste n'est pas nul, car nbpiste-1 ne donne pas -1 avec les size_t
			   (les size_t sont des nombres non-signés) */
			if(nb_piste > 0)
			{
				for(iPiste=0 ; iPiste<nb_piste-1 ; iPiste++)
				{
					size_t iAutrePiste;
					for(iAutrePiste=iPiste+1 ; iAutrePiste<nb_piste ; iAutrePiste++)
					{
						//FONCTION STRCMP(__ , __) COMPARE LES CHAINES DE CARACTERES
						if(strcmp(tab_piste[iPiste].type_vol, tab_piste[iAutrePiste].type_vol) > 0)
						{
							/* Echange */
							piste tempPiste = tab_piste[iPiste];
							tab_piste[iPiste] = tab_piste[iAutrePiste];
							tab_piste[iAutrePiste] = tempPiste;
						}
					}
				}
			}
			
			printf("Les pistes triees par types de vol donnent:\n");
			for(iPiste=0 ; iPiste<nb_piste ; iPiste++)
			{
				printf("\nType de vol:%s\n", tab_piste[iPiste].type_vol);
				printf("Designation:%s\n", tab_piste[iPiste].designation);
			}
			system("pause");
			}
			break;

		case 8:	//TRIER LES STATUTS PAR PISTE
			{
			size_t iPiste;

			system("cls");
			if(nb_piste > 0)
			{
				for(iPiste=0 ; iPiste<nb_piste-1 ; iPiste++)
				{
					size_t iAutrePiste;
					for(iAutrePiste=iPiste+1 ; iAutrePiste<nb_piste ; iAutrePiste++)
					{
						/* Med: Là, j'ai des doutes sur le "=="
						   Je pense que > correspond mieux.
						 */
						if(strcmp(tab_piste[iPiste].statut, tab_piste[iAutrePiste].statut) > 0)
						{
							/* Echange */
							piste tempPiste = tab_piste[iPiste];
							tab_piste[iPiste] = tab_piste[iAutrePiste];
							tab_piste[iAutrePiste] = tempPiste;
						}
					}
				}
			}
			
			printf("Les pistes triees par statut sont:\n");
			for(iPiste=0 ; iPiste<nb_piste ; iPiste++)
			{
				printf("\nStatut:%s\n", tab_piste[iPiste].statut);
				printf("Code piste:%d\n", tab_piste[iPiste].code_piste);
			}
			system("pause");
			}
			break;

		case 9:	//REAFFECTER UN EMPLOYE D'UNE PISTE A UNE AUTRE
			{
			int codeEmplVoulu;
			size_t iEmpl;
			
			system("cls");
			codeEmplVoulu = DemanderNombre("Quel est le code de l'employe a reaffecter?\n", 0);
			iEmpl = TrouverEmploye(tab_employe, nb_employe, codeEmplVoulu);

			if(iEmpl < nb_employe)
			{
				int nouvCodePiste;
				printf("L'employe %s %s\n", tab_employe[iEmpl].nom, tab_employe[iEmpl].prenom);
				printf("Travaille sur la piste %d. ", tab_employe[iEmpl].code_piste);
				nouvCodePiste = DemanderNombre("Sur quel piste voulez vous le reaffecter?\n", 0);
				
				if(TrouverPiste(tab_piste, nb_piste, nouvCodePiste) < nb_piste)
				{
					tab_employe[iEmpl].code_piste = nouvCodePiste;
					printf("La reaffectation est terminee, desormais l'employe %s %s travail sur la piste: %d\n",
					 tab_employe[iEmpl].nom, tab_employe[iEmpl].prenom, tab_employe[iEmpl].code_piste
					 );
				}
				else
					printf("La piste %d n'existe pas.", nouvCodePiste);
			}
			}
			break;

		case 0:
			{
			system("cls");
			printf("Vous quittez le programme de gestion des pistes\n");
			}
			break;

		default:
			printf("Erreur de saisie\n");	// CONCERNE LA FIN DE LA BOUCLE SELON DE LA GESTION DES PISTES
		}

	} while(choix_p!=0);	//SORTIE DE LA GESTION DES PISTES

	*pNPistes = nb_piste;
	*pNEmployes = nb_employe;
}
/*---------------------------------------------------------------------------*/
void ModifierEmploye(employe *pEmpl)
{
	int choix_m;
	do
	{
		printf(" 1. Modifier le nom\n");
		printf(" 2. Modifier le prenom\n");
		printf(" 3. Modifier le numero de telephone\n");
		printf(" 4. Modifier la fonction\n");
		printf(" 5. Modifier le code piste\n");
		printf(" 0. Quitter\n");
		choix_m = DemanderNombre("Choix : ", 0);
		switch(choix_m)
		{
		case 1:
			{
			system("cls");
			DemanderChaine("Donner le nom rectifie\n", pEmpl->nom, ARRAYSIZE(pEmpl->nom));
			}
			break;
		case 2:
			{
			system("cls");
			DemanderChaine("Donner le prenom a rectifier\n", pEmpl->prenom, ARRAYSIZE(pEmpl->prenom));
			}
			break;
		case 3:
			{
			system("cls");
			DemanderChaine("Donner le nouveau numero de telephone\n", pEmpl->tel, ARRAYSIZE(pEmpl->tel));
			}
			break;
		case 4:
			{
			system("cls");
			DemanderChaine("Donner la nouvelle fonction\n", pEmpl->fonction, ARRAYSIZE(pEmpl->fonction));
			}
			break;
		case 5:
			{
			system("cls");
			pEmpl->code_piste = DemanderNombre("Donner le nouveau code piste\n", -1);
			}
			break;
		default:
			printf("Erreur de saisie\n");
		}
	} while (choix_m!=0);
}
/*---------------------------------------------------------------------------*/
void VerifierDoublons(employe const * tab_employe, size_t nb_employe)
{
	int choix_d;
	
	system("cls");
	printf("Verification de doublons\n\n");
	printf("Que voulez vous verifier?\n\n");
	do
	{
		printf(" 1. Verifier les codes employes\n");
		printf(" 2. Verifier les noms\n");
		printf(" 3. Verifier les prenoms\n");
		printf(" 4. Verifier les numero de telephone\n");
		printf(" 0. Quitter\n");
		choix_d = DemanderNombre("Choix : ", 0);

		switch(choix_d)
		{
		case 1:
			{
			system("cls");
			if(nb_employe > 0)
			{
				size_t iEmpl;
				for(iEmpl=0 ; iEmpl<nb_employe-1 ; iEmpl++)
				{
					size_t iAutreEmpl;
					for(iAutreEmpl=iEmpl+1 ; iAutreEmpl<nb_employe ; iAutreEmpl++)
					{
						if(tab_employe[iEmpl].code_employe==tab_employe[iAutreEmpl].code_employe)
							printf("Il y a un doublon du code employe:%d\n", tab_employe[iEmpl].code_employe);
					}
				}
			}
			system("pause");
			}
			break;
		case 2:
			{
			system("cls");
			if(nb_employe > 0)
			{
				size_t iEmpl;
				for(iEmpl=0 ; iEmpl<nb_employe-1 ; iEmpl++)
				{
					size_t iAutreEmpl;
					for(iAutreEmpl=iEmpl+1 ; iAutreEmpl<nb_employe ; iAutreEmpl++)
					{
						/* Med : Ce sont des chaînes, on compare avec strcmp()...
						De plus, il y a DEUX codes à afficher... */
						if(strcmp(tab_employe[iEmpl].nom, tab_employe[iAutreEmpl].nom) == 0)
							printf("Il y a un doublon des noms:%s qui correspond aux codes employe: %d et %d\n",
							 tab_employe[iEmpl].nom,
							 tab_employe[iEmpl].code_employe,
							 tab_employe[iAutreEmpl].code_employe
							 );
					}
				}
			}
			system("pause");
			}
			break;
		case 3:
			{
			system("cls");
			if(nb_employe > 0)
			{
				size_t iEmpl;
				for(iEmpl=0 ; iEmpl<nb_employe-1 ; iEmpl++)
				{
					size_t iAutreEmpl;
					for(iAutreEmpl=iEmpl+1 ; iAutreEmpl<nb_employe ; iAutreEmpl++)
					{
						/* Med : Ce sont des chaînes, on compare avec strcmp()...
						De plus, il y a DEUX codes à afficher... */
						if(strcmp(tab_employe[iEmpl].prenom, tab_employe[iAutreEmpl].prenom) == 0)
							printf("Il y a un doublon des prenoms:%s qui correspond aux codes employe: %d et %d\n",
							 tab_employe[iEmpl].prenom,
							 tab_employe[iEmpl].code_employe,
							 tab_employe[iAutreEmpl].code_employe
							 );
					}
				}
			}
			system("pause");
			}
			break;

		case 4:
			{
			system("cls");
			if(nb_employe > 0)
			{
				size_t iEmpl;
				for(iEmpl=0 ; iEmpl<nb_employe-1 ; iEmpl++)
				{
					size_t iAutreEmpl;
					for(iAutreEmpl=iEmpl+1 ; iAutreEmpl<nb_employe ; iAutreEmpl++)
					{
						/* Med : Ce sont des chaînes, on compare avec strcmp()...
						De plus, il y a DEUX codes à afficher... */
						if(strcmp(tab_employe[iEmpl].tel, tab_employe[iAutreEmpl].tel) == 0)
							printf("Il y a un doublon du tel:%s qui correspond aux codes employe: %d et %d\n",
							 tab_employe[iEmpl].tel,
							 tab_employe[iEmpl].code_employe,
							 tab_employe[iAutreEmpl].code_employe
							 );
					}
				}
			}
			system("pause");
			}

		case 0:
			{
			system("cls");
			printf("Vous quittez le programme de control des doublons\n");
			}
			break;

		default:
			printf("Erreur de saisie\n");
		}
	} while(choix_d!=0);
}

/*---------------------------------------------------------------------------*/
void GestionDesEmployes(employe * tab_employe, size_t *pNEmployes, size_t maxEmployes)
{
	//size_t nb_piste = *pNPistes;
	size_t nb_employe = *pNEmployes;

	int choix_e;
	do
	{
		choix_e = ChoixMenuEmploye();
		switch (choix_e)
		{
		case 1:	//AJOUTER UN EMPLOYE
			{
			system("cls");
			if(nb_employe >= maxEmployes)
				printf("Nb max d'employes (%d) atteint.\n", (int)maxEmployes);
			else
			{
				printf("Vous allez saisir un employe\n");
				tab_employe[nb_employe].code_employe = DemanderNombre("Saisir le code employe\n", -1);
				DemanderChaine("Saisir le nom\n", tab_employe[nb_employe].nom, ARRAYSIZE(tab_employe[nb_employe].nom));
				DemanderChaine("Saisir le prenom\n", tab_employe[nb_employe].prenom, ARRAYSIZE(tab_employe[nb_employe].prenom));
				DemanderChaine("Saisir le numero de telephone\n", tab_employe[nb_employe].tel, ARRAYSIZE(tab_employe[nb_employe].tel));
				DemanderChaine("Saisir la fonction\n", tab_employe[nb_employe].fonction, ARRAYSIZE(tab_employe[nb_employe].fonction));
				tab_employe[nb_employe].code_piste = DemanderNombre("Saisir le code piste\n", -1);
				nb_employe++;
				printf("\nIl y a maintenant %d employes\n\n", (int)nb_employe);
			}
			system("pause");
			}
			break;

		case 2:	//CONSULTER UNE EMPLOYE
			{
			int codeEmplVoulu;
			size_t iEmpl;
			
			system("cls");
			codeEmplVoulu = DemanderNombre("Quel code employe voulez vous consulter?\n", 0);
			iEmpl = TrouverEmploye(tab_employe, nb_employe, codeEmplVoulu);

			if(iEmpl < nb_employe)
			{
				printf("Les renseignements sur l'employe du code:%d sont:\n", codeEmplVoulu);
				printf("Nom: %s\n", tab_employe[iEmpl].nom);
				printf("Prenom: %s\n", tab_employe[iEmpl].prenom);
				printf("Telephone: %s\n", tab_employe[iEmpl].tel);
				printf("Fonction: %s\n", tab_employe[iEmpl].fonction);
				printf("Code piste: %d\n", tab_employe[iEmpl].code_piste);
				system("pause");
			}
			else 
				printf("Erreur de saisie\n");
			}
			break;

		case 3:	//MODIFIER UN EMPLOYE
			{
			int codeEmplVoulu;
			size_t iEmpl;
			
			system("cls");
			codeEmplVoulu = DemanderNombre("Donner le code de l'employe a modifier\n", 0);
			iEmpl = TrouverEmploye(tab_employe, nb_employe, codeEmplVoulu);

			if(iEmpl < nb_employe)
				ModifierEmploye(&tab_employe[iEmpl]);
			else
				printf("Erreur de saisie\n");
			}
			break;

		case 4:	//SUPPRIMER UN EMPLOYE
			{
			int codeEmplVoulu;
			size_t iEmpl;
			
			system("cls");
			codeEmplVoulu = DemanderNombre("Donner le code de l'employe a supprimer\n", 0);
			iEmpl = TrouverEmploye(tab_employe, nb_employe, codeEmplVoulu);

			if(iEmpl < nb_employe)
			{
				/* Med: Il faut diminuer le nombre total AVANT la copie,
				   sinon on copie un employe qui n'existe pas. */
				nb_employe--;
				tab_employe[iEmpl] = tab_employe[nb_employe];
			}
			else
				printf("Erreur de saisie\n");
			}
			break;

		case 5:	//TRIER LES EMPLOYES PAR NUMERO DE PISTE
			{
			size_t iEmpl;
			system("cls");
			
			if(nb_employe > 0)
			{
				for(iEmpl=0 ; iEmpl<nb_employe-1 ; iEmpl++)
				{
					size_t iAutreEmpl;
					for(iAutreEmpl=iEmpl+1 ; iAutreEmpl<nb_employe ; iAutreEmpl++)
					{
						/* Med: Il faudra qu'un jour tu m'expliques 
						   pourquoi tu t'obstines à trier sur une égalité...
						   D'ailleurs, ce n'est pas = qu'il aurait fallu mettre, mais ==
						   --> Ton compilo aurait du te donner un warning...
						if(tab_employe[i].code_piste=tab_employe[j].code_piste) */
						if(tab_employe[iEmpl].code_piste > tab_employe[iAutreEmpl].code_piste)
						{
							/* Là encore, pourquoi +1 ?
							tempemploye = tab_employe[i+1];
							tab_employe[i+1]=tab_employe[j];
							tab_employe[j]=tempemploye; */
							employe tempEmploye = tab_employe[iEmpl];
							tab_employe[iEmpl] = tab_employe[iAutreEmpl];
							tab_employe[iAutreEmpl] = tempEmploye;
						}
					}
				}
			}
			
			printf("Les employes tries par pistes sont:\n");
			for(iEmpl=0 ; iEmpl<nb_employe ; iEmpl++)
			{
				printf("\nCode piste: %d\n", tab_employe[iEmpl].code_piste);
				printf("Code employe: %d\n", tab_employe[iEmpl].code_employe);
				printf("Nom: %s\n", tab_employe[iEmpl].nom);
				printf("Prenom: %s\n", tab_employe[iEmpl].prenom);
			}
			system("pause");
			}
			break;

		/* Med: Là, on ne comprend pas ce que tu veux faire, mais ce n'est sûremnet pas un tri.
		   Je désactive le code car il n'est pas rattrappable. */
		#if 0
		case 6:	// TRIER LES EMPLOYES DE L'INTERNATIONAL
		{
		system("cls");

		for(i=0;i<nb_piste;i++)
		{
			if(strcmp(tab_piste[i].type_vol,"international") == 0)
			{
				for(j=0;j<nb_employe;j++)
				{
					if(tab_piste[i].code_piste==tab_employe[j].code_piste)
					{
						printf("\n\nLes employes tries de l'international sont:\n");
						printf("\nCode employe: %d\n",tab_employe[j].code_employe);
						printf("Nom: %s\n",tab_employe[j].nom);
						printf("Prenom: %s\n",tab_employe[j].prenom);
						printf("Fonction: %s\n",tab_employe[j].fonction);
					}
				}
			}
		}
		system("pause");
		}
		break;

		case 7:	//TRIER LES EMPLOYES DE LA NATIONALE
			{
			system("cls");

			for(i=0;i<nb_piste;i++)
			{
				if(strcmp(tab_piste[i].type_vol,"national") == 0)
				{
					for(j=0;j<nb_employe;j++)
					{
						if(tab_piste[i].code_piste==tab_employe[j].code_piste)
						{
							printf("\n\nLes employes tries de la national sont:\n");
							printf("\nCode employe: %d\n",tab_employe[j].code_employe);
							printf("Nom: %s\n",tab_employe[j].nom);
							printf("Prenom: %s\n",tab_employe[j].prenom);
							printf("Fonction: %s\n",tab_employe[j].fonction);
						}
					}
				}
			}
			system("pause");
			}
			break;
		#endif

		case 8:	//TRIER LES EMPLOYES PAR FONCTION
			{
			size_t iEmpl;
			system("cls");
			
			if(nb_employe > 0)
			{
				for(iEmpl=0 ; iEmpl<nb_employe-1 ; iEmpl++)
				{
					size_t iAutreEmpl;
					for(iAutreEmpl=iEmpl+1 ; iAutreEmpl<nb_employe ; iAutreEmpl++)
					{
						/* Med: Il faudra qu'un jour tu m'expliques 
						   pourquoi tu t'obstines à trier sur une égalité...
						   Surtout qu'ici, c'est une chaîne --> strcmp()
						if(tab_employe[i].fonction==tab_employe[j].fonction) */
						if(strcmp(tab_employe[iEmpl].fonction, tab_employe[iAutreEmpl].fonction) > 0)
						{
							employe tempEmploye = tab_employe[iEmpl];
							tab_employe[iEmpl] = tab_employe[iAutreEmpl];
							tab_employe[iAutreEmpl] = tempEmploye;
						}
					}
				}
			}

			printf("Les employes tries par fonction sont:\n");
			for(iEmpl=0 ; iEmpl<nb_employe ; iEmpl++)
			{
				printf("\nCode employe: %d\n", tab_employe[iEmpl].code_employe);
				printf("Nom: %s\n", tab_employe[iEmpl].nom);
				printf("Prenom: %s\n", tab_employe[iEmpl].prenom);
				printf("Fonction: %s\n", tab_employe[iEmpl].fonction);
			}
			system("pause");
			}
			break;

		case 9:	//VERIFIER LES DOUBLONS
			VerifierDoublons(tab_employe, nb_employe);
			break;

		case 0:
			{
			printf("Vous quittez le programme de gestion des employes\n");
			}
			break;

		default:
			printf("Erreur de saisie\n");	// CONCERNE LA FIN DE LA BOUCLE SELON DE LA GESTION DES EMPLOYES	
		}
	} while(choix_e!=0);	//SORTIE DE LA GESTION DES EMPLOYE

	//*pNPistes = nb_piste;
	*pNEmployes = nb_employe;
}
/*---------------------------------------------------------------------------*/
void Statistiques(piste * tab_piste, size_t nb_piste, employe * tab_employe, size_t nb_employe)
{
	int choix_s;
	do
	{
		choix_s = ChoixMenuStatistiques();
		switch(choix_s)
		{
			case 1:	//PISTE / NB EMPLOYES
			{
			if(nb_employe == 0)
				printf("Il n'y a aucun employe.\n");
			else
			{			
				/* Med: sur une machine moderne, il est conseillé d'utiliser toujours des doubles.
				   Car de toute façon, les calculs flottants se font par doubles. */
				double rapport = nb_piste * 1.0 / nb_employe;
				double pourcent = rapport * 100.0;
				
				system("cls");
				/* Med: Qu'est-ce que c'est que ce calcul ?  calc=0;
				calc=nb_piste*100/nb_employe;*/
				/* Med: Pour afficher un % dans printf(), on utilise %% */
				printf("Il y a donc un taux de: %.2f%% de pistes par employes\n", pourcent);
				printf("Car il y a %d de piste et %d d'employes\n", (int)nb_piste, (int)nb_employe);
			}
			system("pause");
			}
			break;
		case 2:	//MIN & MAX
			{
			system("cls");

			CompterEmployesPistes(tab_piste, nb_piste, tab_employe, nb_employe);
			TrierPistesNbEmployes(tab_piste, nb_piste);

			printf("Il y a donc au maximum: %d employe sur une piste et au minimum: %d\n",
			 tab_piste[0].nb_empl,
			 tab_piste[nb_piste-1].nb_empl
			 );
			system("pause");
			}
			break;
		case 3:	// MOY EMPLOYES / PISTES
			{
			if(nb_piste == 0)
				printf("Il n'y a aucune piste.\n");
			else
			{
				double rapport = nb_employe * 1.0 / nb_piste;

				system("cls");
				printf("Il y a donc une moyenne de: %.2f d'employes par piste\n", rapport);
			}
			system("pause");
			}
			break;

		case 4:	// NOMBRE D'EMPLOYE PAR STATUT
			{
			size_t rstS;
			size_t iPiste;
			CompterEmployesPistes(tab_piste, nb_piste, tab_employe, nb_employe);
			/* Med: inutile de trier ici... */
					
			// ANALYSER LES STATUTS

			/* Rassemble les nombres d'employés des pistes ayant le même statut dans la permière piste trouvée,
			   et place les autres pistes en dernier. */
			rstS=nb_piste;

			for(iPiste=0 ; iPiste<nb_piste ; iPiste++)
			{
				size_t iAutrePiste;
				for(iAutrePiste=iPiste+1 ; iAutrePiste<rstS ; iAutrePiste++)
				{
					if(strcmp(tab_piste[iPiste].statut, tab_piste[iAutrePiste].statut) == 0)
					{
						piste tempPiste;
						
						tab_piste[iPiste].nb_empl += tab_piste[iAutrePiste].nb_empl;
						/* Place la piste en dernier et réduit le champ de recherche
						  (ressemble presque à une suppression, c'est fait pour)
						tempiste=tab_piste[j];
						tab_piste[j]=tab_piste[nb_piste];
						tab_piste[nb_piste]=tempiste;
						rstS--; */
						rstS--;
						tempPiste = tab_piste[iAutrePiste];
						tab_piste[iAutrePiste] = tab_piste[rstS];
						tab_piste[rstS] = tempPiste;
					}
				}
			}

			system("cls");
			printf("Il y a donc :\n");
			for(iPiste=0 ; iPiste<rstS ; iPiste++)
			{
				printf("\nStatut:%s\n", tab_piste[iPiste].statut);
				printf("Nombre d'employes:%d\n", tab_piste[iPiste].nb_empl);
			}
			system("pause");
			}
			break;

		case 5:	// NOMBRE D'EMPLOYE PAR TYPE DE VOL
			{
			size_t rstT;
			size_t iPiste;
			CompterEmployesPistes(tab_piste, nb_piste, tab_employe, nb_employe);
					
			// ANALYSER LES TYPES DE VOL
			/* Rassemble les nombres d'employés des pistes ayant le même type de vol dans la permière piste trouvée,
			   et place les autres pistes en dernier. */

			rstT=nb_piste;

			for(iPiste=0 ; iPiste<nb_piste ; iPiste++)
			{
				size_t iAutrePiste;
				for(iAutrePiste=iPiste+1 ; iAutrePiste<rstT ; iAutrePiste++)
				{
					if(strcmp(tab_piste[iPiste].type_vol,tab_piste[iAutrePiste].type_vol)==0)
					{
						piste tempPiste;
						
						tab_piste[iPiste].nb_empl += tab_piste[iAutrePiste].nb_empl;
						
						/* Place la piste en dernier et réduit le champ de recherche
						  (ressemble presque à une suppression, c'est fait pour) */
						rstT--;
						tempPiste = tab_piste[iAutrePiste];
						tab_piste[iAutrePiste] = tab_piste[rstT];
						tab_piste[rstT] = tempPiste;
					}
				}
			}

			system("cls");
			printf("Il y a donc:\n");
			for(iPiste=0 ; iPiste<rstT ; iPiste++)
			{
				printf("\nType de vol:%s\n", tab_piste[iPiste].type_vol);
				printf("Nombre d'employes:%d\n", tab_piste[iPiste].nb_empl);
			}
			system("pause");
			}
			break;

		case 6:	//NOMBRE EMPLOYES / FONCTION
			{
			size_t iEmpl;
			size_t rstF;

			//COMPTER LE NOIMBRE D'EMPLOYES PAR PISTE
			// TRIER LES EMPLOYES PAR PISTES
			/* Med: ça ne sert à rien ici... */
					
			// ANALYSER LES FONCTION

			rstF=nb_employe;

			for(iEmpl=0 ; iEmpl<nb_employe ; iEmpl++)
			{
				size_t iAutreEmpl;
				tab_employe[iEmpl].nb_empl=1; /*Med: 1, pas 0... */
				
				for(iAutreEmpl=iEmpl+1 ; iAutreEmpl<nb_employe ; iAutreEmpl++)
				{
					if(strcmp(tab_employe[iEmpl].fonction, tab_employe[iAutreEmpl].fonction)==0)
					{
						employe tempEmploye;
						
						tab_employe[iEmpl].nb_empl += tab_employe[iAutreEmpl].nb_empl;
						/* Place l'employé en dernier et réduit le champ de recherche
						  (ressemble presque à une suppression, c'est fait pour) */
						rstF--;
						tempEmploye = tab_employe[iAutreEmpl];
						tab_employe[iAutreEmpl] = tab_employe[rstF];
						tab_employe[rstF] = tempEmploye;
					}
				}
			}

			system("cls");
			printf("Il y a donc:\n");
			printf("%d", (int)rstF);
			for(iEmpl=0 ; iEmpl<rstF ; iEmpl++)
			{
				printf("\nFonction:%s\n", tab_employe[iEmpl].fonction);
				printf("Nombre d'employes:%d\n", tab_employe[iEmpl].nb_empl);
			}
			system("pause");
			}
			break;

		case 0:
			printf("Vous quittez le programme des statistiques\n");
			break;

		default:
			printf("Erreur de saisie\n");
		}
	} while(choix_s!=0);
}
/*---------------------------------------------------------------------------*/
int avion_main(void)
{
	// ****DECLARATIONS****
	/* Med: On déplace toutes les variables dans les fonctions où elles doivent être. */
	/* Med: On utilise des size_t pour les tailles, tableaux, etc. */
	//TABLEAUX
	piste tab_piste[100];
	employe tab_employe[100];
	//ENTIERS
	size_t nb_piste, nb_employe;
	int choix;

	// ****DEBUT****
	
	//ON PART D'UNE PRINCIPE OU IL EXISTE AU MINIMUM UNE PISTE ET UN SALARIE
	/* Med : Ben non. */
	nb_piste=0;
	nb_employe=0;

	// ***AFFICHAGE DU MENU PRINCIPAL***
	do 
	{
		choix = ChoixMenuPrincipal();
		switch(choix)
		{
		case 1:	// ***GESTION DES PISTES***
			GestionDesPistes(tab_piste, &nb_piste, ARRAYSIZE(tab_piste), tab_employe, &nb_employe);
			break;		

		case 2:	// ***GESTION DES EMPLOYES***
			GestionDesEmployes(tab_employe, &nb_employe, ARRAYSIZE(tab_employe));
			break;

		case 3: // ***STATISTIQUES***
			Statistiques(tab_piste, nb_piste, tab_employe, nb_employe);
			break;

		case 0:
			break;
		default:
			printf("Erreur de saisie\n");	// FIN DE LA BOUCLE SELON DU MENU PRINCIPAL			
		}
	} while(choix!=0);	// SORTIE DE LA GESTION DU MENU PRINCIPAL
	
//system("pause");
return 0;
}