#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#pragma warning(disable : 4996)

#define maxTours 10
#define maxEpreuves 16
#define nbPatineursParEquipes 3
#define nbEquipeParEpreuves 2
#define tailleMaxChaine 30
#define nbMaxEquipes 32

typedef struct {
	double temps;
}Mesure;

typedef struct {
	char nom[tailleMaxChaine];
	unsigned int dossard;
	Mesure listeTemps[maxTours];
	unsigned int tourEffectue;
}Patineur; // Une variable de type "Patineur" va stocker le nom et le numéro de dossard d'un patineur

typedef struct {
	char nomPays[tailleMaxChaine];
	Patineur patineur[nbPatineursParEquipes]; //Rappel nbPatineursParEquipes = 3
}Equipe; // Une variable de type "Equipe" va stocker le pays d'origine de l'équipe et un tableau qui contient tous les patineurs de l'équipe

typedef struct {
	Equipe tabEquipe[nbEquipeParEpreuves];
	unsigned int numEpreuve;
	int etatEpreuve;
}Epreuve;

typedef struct {
	Epreuve tabEpreuve[maxEpreuves];
	unsigned int compteurEpreuve;
	unsigned int nbTour; //Enregistre le nb de tour à effectué à chaque épreuve grâce à la commande "definir_parcours"
	unsigned int nbEpreuve; // enregistre le nb d'épreuve de la compet grace a la commande "defini_nb_epreuve"
	unsigned int cptDernier; /* à chaque fois qu'on enregistre le patineur le plus lent d'une équipe, on incrémente le compteur dernier de 1,
							 cela permet de savoir combien il y a de valeur dans le tableau "dernierPatineur" */
	double dernierPatineur[nbMaxEquipes]; // c'est un tableau qui stock les patineurs les plus lents de chaque équipe
	int etatCompet;
}Competition;

//Prototype des fontions
void inscription_equipe(Equipe* pointeurEquipe, int* pointeurNumDossard);

void affichage_equipe(const Equipe* pointeurEquipe);

void recherche_dossard(const Equipe* pointeurEquipe, unsigned int* pointeurEntrerDossard, int* pointeurNumEquipe, int* pointeurNumPatineur);

void enregistrement_temps(Equipe* pointeurEquipe, Competition* pointeurCompet);

void affichage_temps(const Equipe* pointeurEquipe);

void affichage_temps_equipes(const Equipe* pointeurEquipe, const int pointeurCptEquipe);

void affichage_temps_equipes_avec_classement(const Equipe* pointeurEquipe, const int pointeurCptEquipe, unsigned int pointeurEntrerTour, Competition* pointeurCompet);

void definition_parcours(Competition* pointeurCompet);

void detection_fin_poursuite(Competition* pointeurCompet, int pointeurIdxEpreuve);

void definition_nb_epreuves(Competition* pointeurCompet);

void detection_fin_competition(Competition* pointeurCompet);

//main
int main() {
	char commande[tailleMaxChaine] = ""; //La variable "commande" reçoit les commandes qu'on va rentrer
	Equipe equipe[nbMaxEquipes]; //Rappel nbMaxEquipe = 32
	int numDossard = 101, compteurEquipeInscrit = 0;
	Competition competition;
	competition.compteurEpreuve = 0;
	competition.cptDernier = 0;

	do {
		scanf("%s", commande);
		if (strcmp(commande, "definir_parcours") == 0) {
			definition_parcours(&competition);
		}
		if (strcmp(commande, "definir_nombre_epreuves") == 0) {
			definition_nb_epreuves(&competition);
		}
		if (strcmp(commande, "inscrire_equipe") == 0) { // compare si la commande rentrée par le clavier == "inscrire_equipe", si oui, on rentre dans la condition

			inscription_equipe(&equipe[compteurEquipeInscrit], &numDossard); /* Cette fonction nous permet de rentrer les données concernant les patineurs et
																			 l'équipe dans la varianle "pays" de type "Equipe"*/

			compteurEquipeInscrit++; /* on incrémente "compteurEquipeInscrit" pour que la prochaine fois qu'on inscrit une équipe, les données de la nouvelle
									 équipes soient rangées dans le rang suivant du tableau "equipe", c'est a dire par exemple que l'équipe Canada sera rangée
									 dans equipe[0] tandis que l'équipe Japon sera rangée dans equipe[1]*/
			if (compteurEquipeInscrit % nbEquipeParEpreuves == 0) {
				(competition.compteurEpreuve)++;
			}
		}
		if (strcmp(commande, "afficher_equipes") == 0) { // compare si la commande rentrée par le clavier == "afficher_equipes", si oui, on rentre dans la condition
			for (int i = 0; i < compteurEquipeInscrit; i++) { // On affiche les données des équipes stocker dans le tableau "equipe"
				affichage_equipe(&equipe[i]);
			}
		}
		if (strcmp(commande, "enregistrer_temps") == 0) {
			enregistrement_temps(equipe, &competition);
		}
		if (strcmp(commande, "afficher_temps") == 0) {
			affichage_temps(equipe);
		}
		if (strcmp(commande, "afficher_temps_equipes") == 0) {
			affichage_temps_equipes(equipe, compteurEquipeInscrit);
		}
		if (strcmp(commande, "exit") == 0) { // compare si la commande rentrée par le clavier == "exit", si oui, on arrêt tous
			exit(0);
		}
	} while (1);
}

//Fonctions
void inscription_equipe(Equipe* pointeurEquipe, int* pointeurNumDossard) {

	scanf("%s", pointeurEquipe->nomPays); //

	for (int i = 0; i < nbPatineursParEquipes; i++) { //On crée une boucle pour rentrer le nom des patineurs, ici i = 0 ou 1 ou 2
		scanf("%s", pointeurEquipe->patineur[i].nom); //

		pointeurEquipe->patineur[i].dossard = *pointeurNumDossard; // On attribut un numéro de dossard au patineur au rang i
		printf("inscription dossard %d\n\n", *pointeurNumDossard);
		(*pointeurNumDossard)++;  /* Ici NumDossard est un pointeur donc lorsque on sortira de la fonction "inscription_equipe", la variable NumDossard ne va pas
								  disparaitre, elle va conserver la derniere valeur qu'on lui a attribuer. */
	}
}

void affichage_equipe(const Equipe* pointeurEquipe) {
	printf("%s ", pointeurEquipe->nomPays); // affiche le pays originaire de l'une équipe

	for (int i = 0; i < nbPatineursParEquipes; i++) { // c'est une boucle qui affiche le nom et le dossard de tous les patineurs d'une équipe
		if (i == (nbPatineursParEquipes - 1)) {
			printf("%s %d", pointeurEquipe->patineur[i].nom, pointeurEquipe->patineur[i].dossard);
		}
		else {
			printf("%s %d ", pointeurEquipe->patineur[i].nom, pointeurEquipe->patineur[i].dossard);
		}
	}
	printf("\n\n");
}

void recherche_dossard(const Equipe* pointeurEquipe, unsigned int* pointeurEntrerDossard, int* pointeurNumEquipe, int* pointeurNumPatineur) {
	do {
		if (pointeurEquipe[*pointeurNumEquipe].patineur[*pointeurNumPatineur].dossard != *pointeurEntrerDossard) {
			(*pointeurNumPatineur)++;
			if (*pointeurNumPatineur >= nbPatineursParEquipes) { /* Si le numéro du patineur dépasse le nombre de patineur autorisé par équipe, c'est-à-dire 3,
					 alors on incrémente numEquipe de 1 et on réinitialise numPatineur à 0, cela veut dire qu'on va chercher
					 dans l'équipe suivante le patineur correspondant au numéro de dossard demandé */
				(*pointeurNumEquipe)++;
				*pointeurNumPatineur = 0;
			}
			if (*pointeurNumEquipe >= nbMaxEquipes) {
				printf("le numéro de dossard demandé n'existe pas ou n'est pas encore attribué !\n\n");
				exit(0);
			}
		}
		else {
			break;
		}
	} while (1);
}

void enregistrement_temps(Equipe* pointeurEquipe, Competition* pointeurCompet) {
	unsigned int entrerDossard = 0, entrerTour;
	double entrerTemps = 0.;
	int numEquipe = 0, numPatineur = 0, idxEpreuve = 0, idxEquipe = 0;
	scanf("%u", &entrerDossard);

	recherche_dossard(pointeurEquipe, &entrerDossard, &numEquipe, &numPatineur);

	scanf("%u", &entrerTour);
	pointeurEquipe[numEquipe].patineur[numPatineur].tourEffectue = entrerTour;
	scanf("%lf", &entrerTemps);
	pointeurEquipe[numEquipe].patineur[numPatineur].listeTemps[entrerTour - 1].temps = entrerTemps;

	/*Entrer les données d'une équipe dans la variable "Compétition"*/
	idxEpreuve = (entrerDossard - 101) / 6; /*Permet de trouver le num de l'épreuve où se trouve le patineur correspondant au dossard entrer dans le scanf*/
	if ((entrerDossard - 101) % 6 >= 3) {
		idxEquipe = 1;
	}
	pointeurCompet->tabEpreuve[idxEpreuve].tabEquipe[idxEquipe] = pointeurEquipe[numEquipe];

	// Appelle de la fontion "detection_fin_poursuite"
	detection_fin_poursuite(pointeurCompet, idxEpreuve);
}

void affichage_temps(const Equipe* pointeurEquipe) {
	unsigned int entrerDossard;
	int numEquipe = 0, numPatineur = 0;
	scanf("%u", &entrerDossard);

	recherche_dossard(pointeurEquipe, &entrerDossard, &numEquipe, &numPatineur);

	unsigned int tourEffectue = pointeurEquipe[numEquipe].patineur[numPatineur].tourEffectue;
	for (unsigned int numTour = 0; numTour < maxTours; numTour++) {
		if (numTour < tourEffectue) {
			printf("%s %u %s %.1f\n\n", pointeurEquipe[numEquipe].nomPays, numTour + 1,
				pointeurEquipe[numEquipe].patineur[numPatineur].nom, pointeurEquipe[numEquipe].patineur[numPatineur].listeTemps[numTour].temps);
		}
	}
}

void affichage_temps_equipes(const Equipe* pointeurEquipe, const int pointeurCptEquipe) { /*Fonction qui va afficher selon le tour demandé,
																							le nom du pays et le temps du dernier patineur de chaque équipe */
	double dernier;
	int i = 0, j = 0;
	unsigned int entrerTour;
	scanf("%u", &entrerTour);
	entrerTour--;

	for (i = 0; i < pointeurCptEquipe; i++) {
		printf("%s ", pointeurEquipe[i].nomPays);

		dernier = pointeurEquipe[i].patineur[j].listeTemps[entrerTour].temps;
		for (j = 0; j < nbPatineursParEquipes; j++) {
			if (pointeurEquipe[i].patineur[j].tourEffectue < (entrerTour + 1)) { /*Les données au tour n sont stokées dans le tableau tempsAuTourN[n-1]*/
				printf("indiponible\n\n");
				break;
			}
			if (dernier < pointeurEquipe[i].patineur[j].listeTemps[entrerTour].temps) {
				dernier = pointeurEquipe[i].patineur[j].listeTemps[entrerTour].temps;
			}
			if (j == nbPatineursParEquipes - 1) {
				printf("%.1f\n\n", dernier);
			}
		}
		j = 0;
	}
}

void affichage_temps_equipes_avec_classement(const Equipe* pointeurEquipe, const int CptEquipe, unsigned int EntrerTour, Competition* pointeurCompet) { /*Fonction qui va afficher selon le tour demandé, le nom du pays et le temps
																					 du dernier patineur de chaque équipe */
	double tabDernier[nbEquipeParEpreuves] = { 0. };
	int i = 0, j = 0, r = 0;
	EntrerTour--;

	for (i = 0; i < CptEquipe; i++) {

		tabDernier[i] = pointeurEquipe[i].patineur[j].listeTemps[EntrerTour].temps;
		for (j = 0; j < nbPatineursParEquipes; j++) {
			if (pointeurEquipe[i].patineur[j].tourEffectue < (EntrerTour + 1)) {
				printf("indiponible\n\n");
				break;
			}
			if (tabDernier[i] < pointeurEquipe[i].patineur[j].listeTemps[EntrerTour].temps) {
				tabDernier[i] = pointeurEquipe[i].patineur[j].listeTemps[EntrerTour].temps;
			}
		}
		pointeurCompet->dernierPatineur[pointeurCompet->cptDernier] = tabDernier[i];
		(pointeurCompet->cptDernier)++;
		j = 0;
	}
	if (tabDernier[r] < tabDernier[r + 1]) { //Le problème ici c'est que ça ne marche que s'il n'y a que 2 équipes par épreuves
		printf("%s %.1f\n\n", pointeurEquipe[r].nomPays, tabDernier[r]);
		printf("%s %.1f\n\n", pointeurEquipe[r + 1].nomPays, tabDernier[r + 1]);
	}
	else {
		printf("%s %.1f\n\n", pointeurEquipe[r + 1].nomPays, tabDernier[r + 1]);
		printf("%s %.1f\n\n", pointeurEquipe[r].nomPays, tabDernier[r]);
	}
}

void definition_parcours(Competition* pointeurCompet) {
	unsigned int entrerNbTour;
	scanf("%u", &entrerNbTour);
	if (entrerNbTour >= 2 && entrerNbTour <= 10) {
		pointeurCompet->nbTour = entrerNbTour;
	}
	else {
		printf("Le nb de tour rentré n'est pas valide.\n\n");
	}
}

void detection_fin_poursuite(Competition* pointeurCompet, int pointeurIdxEpreuve) {
	pointeurCompet->tabEpreuve[pointeurIdxEpreuve].etatEpreuve = 1; // 1 = Epreuve Terminer ; 0 = Epreuve en cours

	for (int idxEquipe = 0; idxEquipe < nbEquipeParEpreuves; idxEquipe++) {
		for (int idxPatineur = 0; idxPatineur < nbPatineursParEquipes; idxPatineur++) {
			if ((pointeurCompet->tabEpreuve[pointeurIdxEpreuve].tabEquipe[idxEquipe].patineur[idxPatineur].tourEffectue) < pointeurCompet->nbTour) {
				pointeurCompet->tabEpreuve[pointeurIdxEpreuve].etatEpreuve = 0;
				break;
			}
		}
	}
	if (pointeurCompet->tabEpreuve[pointeurIdxEpreuve].etatEpreuve == 1) { // si etatEpreuve = 1 alors on rentre dans la condition if
		printf("detection_fin_poursuite\n\n");
		affichage_temps_equipes_avec_classement(pointeurCompet->tabEpreuve[pointeurIdxEpreuve].tabEquipe, nbEquipeParEpreuves, pointeurCompet->nbTour, pointeurCompet);
	}

	// Appelle de la fontion "detection_fin_compettion"
	detection_fin_competition(pointeurCompet);
}

void definition_nb_epreuves(Competition* pointeurCompet) {
	unsigned int entrerNbEpreuve;
	scanf("%u", &entrerNbEpreuve);
	if (entrerNbEpreuve >= 1 && entrerNbEpreuve <= 16) {
		pointeurCompet->nbEpreuve = entrerNbEpreuve;
	}
	else {
		printf("Le nombre d'epreuve rentre n'est pas valide.\n\n");
	}
}

void detection_fin_competition(Competition* pointeurCompet) {
	pointeurCompet->etatCompet = 1; // 1 = Compet Terminer ; 0 = Compet en cours

	for (unsigned int idxEpreuve = 0; idxEpreuve < (pointeurCompet->nbEpreuve); idxEpreuve++) {
		if (pointeurCompet->tabEpreuve[idxEpreuve].etatEpreuve != 1) {
			pointeurCompet->etatCompet = 0;
		}
	}
	if (pointeurCompet->etatCompet == 1) { // si etatCompet = 1 alors on rentre dans la condition if
		printf("detection_fin_Competition\n\n");
		// Boucle pour tester les valeurs dans le tableau "DernierPatineur" (A enlever apres avoir fini le sprint5)
		for (unsigned int i = 0; i < pointeurCompet->cptDernier; i++) {
			printf("%.1f\n", pointeurCompet->dernierPatineur[i]);
		}
		// Algo de tri
		double v;
		unsigned int j;
		for (unsigned int k = 1; k < pointeurCompet->cptDernier; k++) {
			v = pointeurCompet->dernierPatineur[k];
			j = k;
			while (j > 0 && (pointeurCompet->dernierPatineur[j - 1]) > v) {
				pointeurCompet->dernierPatineur[j] = pointeurCompet->dernierPatineur[j - 1];
				j = j - 1;
			}
			pointeurCompet->dernierPatineur[j] = v;
		}
		//Affiche les tmps après algo de tri
		printf("Après Algo de tri\n\n");
		for (unsigned int i = 0; i < pointeurCompet->cptDernier; i++) {
			printf("%.1f\n", pointeurCompet->dernierPatineur[i]);
		}

		// Mettre ici un algo qui permet de retrouver le pays grace au temps inscrit dans le tab "dernierPatineur" trié avec l'algo de tri



	}


}