#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "sae1-02.h"

// Partie 1

// PARTIE ENREGISTREMENT
Listdept initialisation(void) {
    return NULL;
}

VilleIUT lireVille(FILE *fe) {
		VilleIUT v;
		fscanf(fe, "%s %d", v.Ville, &v.nbIUT);
		return v;
}

Listdept lireDept(FILE *fe, int nbIUT) {
	if(nbIUT == 0) return NULL;
	MaillonDept* d;
	d = (MaillonDept*)malloc(sizeof(MaillonDept));
	fscanf(fe, "%s %d", d->departement, &d->nbplace);
	fgets(d->responsable, 31, fe);
	d->responsable[strlen(d->responsable)-1] = '\0';
	d->suivant = lireDept(fe, nbIUT - 1);
	return d;
}

int chargeIUT(VilleIUT* tIUT[], int taillemax) {
	FILE * fe = fopen("donneesIUT.don", "r");
	int i = 0;
	VilleIUT v;
	Listdept d = initialisation();

	if(fe == NULL) { printf("Erreur ouverture fichier \n"); return -1; }

	v = lireVille(fe);
	while(!feof(fe)) {
		if (i == taillemax) { printf("erreur taille tableau \n"); return -1; }
		tIUT[i] = (VilleIUT*) malloc(sizeof(VilleIUT));
		if(tIUT[i] == NULL) { printf("erreur tab\n"); return -1; }
		d = lireDept(fe, v.nbIUT);
		v.ldept = d;
		*tIUT[i] = v;

		v = lireVille(fe);
		i++;
	}
	fclose(fe);
	return i;
}

// PARTIE UTILISATEUR //////////

// villes contenant un IUT
void afficheVilleIUT(VilleIUT *tville[], int nbville) {
	printf("Villes contenant un IUT : \n");
	for(int i = 0; i < nbville; i++) {
		printf(" - %s\n", tville[i]->Ville);
	}
}

// départements de chaques IUT
void afficheDepartementsIUT(VilleIUT *tville[], int nbville) {
	Listdept d;

	int i = rechercheVille(tville, nbville);
	if (i == -1) return;// cas où rien est trouvé en parcourant le tableau

	d = tville[i]->ldept;
	printf("Département(s) : \n");
	affichageDep(d);
}

// nombre de place 
void afficheDepNbPlace(VilleIUT *tville[], int nbville) {
	printf("Voici le nombre de place pour chaques départements de chaques IUT : \n");
	affichageville(tville, nbville);
}

// IUT avec un département particulier
void afficheIUTdepParticulier(VilleIUT *tville[], int nbville) {
	char rechercheDep[31];
	Listdept d;
	int cpt = 0;
	printf("Quelle département recherchez vous en particulier ? : ");
	scanf("%s", rechercheDep);

	printf("Voici les villes avec le département %s : \n", rechercheDep);
	for (int i = 0; i < nbville; i++) {
		d = tville[i]->ldept;
		if(strcmp(rechercheDep, d->departement) == 0) {
			printf(" - %s\n", tville[i]->Ville);
			cpt++;
		}
	}
	if(cpt == 0) printf("Aucun IUT avec ce département n'a été trouvé\n");
}

// PARTIE ADMINISTRATEUR /////////

// modif nombre place département
void modifPlace(VilleIUT *tville[], int nbville) {
	Listdept d;
	char rechercheDep[31];
	int i = rechercheVille(tville, nbville);
	if (i == -1) return;// cas où rien est trouvé en parcourant le tableau
	d = tville[i]->ldept;
	printf("Et quel département pour %s ? : ", tville[i]->Ville);
	scanf("%s", rechercheDep);
	int cpt = chercheDepModif(d, rechercheDep);
	if(cpt == 0) printf("Aucun département de ce nom\n");
}

int chercheDepModif(Listdept d, char rechercheDep[30]) {
	int cpt = 0;
	if (d == NULL) return cpt;
	if(strcmp(d->departement, rechercheDep) == 0) {
		printf("Nombre de place actuellement : %d\nNouveau nombre de place : ", d->nbplace);
		scanf("%d", &d->nbplace);
		cpt++;
	}
	else return chercheDepModif(d->suivant, rechercheDep);
}

// recherche ville
int rechercheVille(VilleIUT *tville[], int nbville) {
	char recherche[31];
	printf("Quelle IUT recherchez vous ? : ");
	scanf("%s", recherche);
	for(int i = 0; i < nbville; i++) {
		if(strcmp(recherche, tville[i]->Ville) == 0) return i;
	}
	printf("L'IUT n'a pas été trouvé !\n");
	return -1;
}


// ajouter un département IUT
Listdept ajoutDept(int posOptionnel, VilleIUT *tville[], int nbville) {
	int i;
	MaillonDept* m;
	Listdept d;
	m = (MaillonDept*)malloc(sizeof(MaillonDept));
	if (m == NULL) { printf("Problème malloc"); exit(1);}

	if(posOptionnel == -1) i = rechercheVille(tville, nbville); // Demande dans quelle IUT on souhaite ajouter le département
	else i = posOptionnel;
	if (i == -1) return m;
	
	d = tville[i]->ldept;

	printf("Veuillez entrer le nom du nouveau département : ");
	scanf("%s", m->departement);
	printf("Entrez le nombre de place pour le département %s de %s : ", m->departement, tville[i]->Ville);
	scanf("%d ", &m->nbplace);
	printf("Entrez le nom du responsable : ");
	fgets(m->responsable, 31, stdin);
	m->responsable[strlen(m->responsable)-1]='\0';
	m->suivant = d;
	tville[i]->nbIUT++; // augmente le nombre d'IUT enregistré
	if(posOptionnel == -1) tville[i]->ldept = m;
	return m;
}

// ajouter un IUT 
void ajoutIUT(VilleIUT *tIUT[], int *nbville, int taillemax) {
	Listdept d;

	if (*nbville == taillemax) { printf("erreur taille tableau \n"); return; }
	tIUT[*nbville] = (VilleIUT*) malloc(sizeof(VilleIUT));
	if(tIUT[*nbville] == NULL) { printf("erreur tab\n"); return; }

	printf("Entrez le nom de la ville à ajouter: ");
	scanf("%s", tIUT[*nbville]->Ville);
	tIUT[*nbville]->nbIUT = 0;

	d = ajoutDept(*nbville, tIUT, *nbville);
	tIUT[*nbville]->ldept = d;
	*nbville = *nbville + 1;
}

// supprimer un département



Listdept suppressionDept(Listdept d, char rechercheDep[31]){
	Listdept tmp;
	if(d == NULL){ exit(1); }
	if(strcmp(d->departement, rechercheDep) == 0){
		tmp = d->suivant;
		free(d);
		return tmp;
	}
	d = suppressionDept(d->suivant, rechercheDep);
}

void supprDepartement(VilleIUT *tville[], int *nbville) {
	int i = rechercheVille(tville, *nbville);
	if (i == -1) return;
	Listdept d = tville[i]->ldept;


	char rech[31];
	printf("Quel département à supprimer pour la ville de %s : ", tville[i]->Ville);
	scanf("%s", rech);

	tville[i]->ldept = suppressionDept(d, rech);
	tville[i]->nbIUT = tville[i]->nbIUT - 1;

	if (tville[i]->nbIUT == 0) {
		for (i; i < *nbville - 1; i++) {
			strcpy(tville[i]->Ville, tville[i + 1]->Ville);
			tville[i]->nbIUT = tville[i + 1]->nbIUT;
			tville[i]->ldept = tville[i + 1]->ldept;
		}
		*nbville = *nbville - 1;
	}
}

void modifNomResponsable(VilleIUT *tville[], int nbville) {
	int i = rechercheVille(tville, nbville);
	if (i == -1) return;
	Listdept d = tville[i]->ldept;

	char rech[31];
	printf("Modifier le nom du responsable de quel département pour %s ? : ", tville[i]->Ville);
	scanf("%s", rech);

// bug a corriger
	fgets(d->responsable, 31, stdin);
	d->responsable[strlen(d->responsable)-1]='\0';

	fgets(d->responsable, 31, stdin);
	d->responsable[strlen(d->responsable)-1]='\0';

	tville[i]->ldept = d;
}

// PARTIE AFFICHAGE

void affichageDep(Listdept d) {
	if(d == NULL) { return; }
	printf(" - %s\n", d->departement);
	affichageDep(d->suivant);
}

void affichageAllDep(Listdept d){
	if(d == NULL) { return; }
	printf("Département : %s\nNombre place : %d\nResponsable : %s\n\n", d->departement, d->nbplace, d->responsable);
	affichageAllDep(d->suivant);
}

void affichageville(VilleIUT *tville[], int nbville){
	int i;
	Listdept d;
	for(i = 0; i < nbville; i++) {
		d = tville[i]->ldept;
		printf("%s -\n", tville[i]->Ville);
		affichageAllDep(d);
		printf("\n");
	}
}

void sauvegardeDep(Listdept d, FILE *fs) {
	if(d == NULL) return;
	fprintf(fs, "%s\t%d%s\n\n", d->departement, d->nbplace, d->responsable);
	sauvegardeDep(d->suivant, fs);
}

void sauvegarde(VilleIUT *tville[], int nbville) {
	FILE *fs;
    fs = fopen ("donneesIUT.don", "w");
    if (fs == NULL) { printf ("Erreur, ouverture fichier"); return; }

    for (int i = 0; i < nbville; i++) {
    	fprintf(fs, "%s\t%d\n", tville[i]->Ville, tville[i]->nbIUT);
    	sauvegardeDep(tville[i]->ldept, fs);
    }
    fclose(fs);
}

// MENU PARTIE 1

void menuP1Utilisateur(VilleIUT *v[], int nb) {
	int choixP1U = 0;
	printf("---------------------- MENU UTILISATEUR -----------------------\n\n");

	printf("   1 - Consulter les villes avec un IUT\n");
	printf("   2 - Consulter les départements d'un IUT\n");
	printf("   3 - Consulter le nombre de place des départements\n");
	printf("   4 - Consulter les IUT possédant un certain département\n\n");
	
	printf("   9 - Retour\n");

	while (choixP1U >= 1 || choixP1U <= 4) {
		switch (choixP1U) {
			case 1:
				afficheVilleIUT(v, nb);
			case 2:
				afficheDepartementsIUT(v, nb);
			case 3:
				affichageville(v, nb);
			case 4:
				afficheIUTdepParticulier(v, nb);
			case 9:
				sauvegarde(v, nb);// mettre menu général
		}
	}
}

void menuP1Administrateur(VilleIUT *v[], int nb) {
	int choixP1A = 0;
	printf("---------------------- MENU UTILISATEUR -----------------------\n\n");

	printf("   1 - Modifier le nombre de place d'un département\n");
	printf("   2 - Créer un département\n");
	printf("   3 - Créer un IUT\n");
	printf("   4 - Supprimer un département\n\n");
	printf("   5 - Modifier le nom d'un responsable\n\n");
	
	printf("   9 - Retour\n");

	while (choixP1A >= 1 || choixP1A <= 4) {
		switch (choixP1A) {
			case 1:
				modifPlace(v, nb);
			case 2:
				ajoutDept(-1, v, nb);
			case 3:
				ajoutIUT(v, &nb, 100);
			case 4:
				supprDepartement(v, &nb);
			case 5:
				modifNomResponsable(v, nb);
			case 9:
				sauvegarde(v, nb);// mettre menu général
		}
	}
}

/*
void test(void){
	VilleIUT *v[100];
	int nb = chargeIUT(v, 100);
	affichageville(v, nb);
	affichageville(v, nb);

	sauvegarde(v, nb);
	
	afficheVilleIUT(v, nb);
	afficheDepartementsIUT(v, nb);
	afficheIUTdepParticulier(v, nb);
	modifPlace(v, nb);
	affichageville(v, nb);
	ajoutIUT(v, &nb, 100);
	ajoutDept(-1, v, nb);
	supprDepartement(v, &nb);
	affichageville(v, nb);
	
}
*/

// Partie 2

//chargement ======================================================================================================================================================================

Listchoixdept listvide(void){return NULL;}

Listchoixdept lireCarte(FILE *fe, int nbchoix){
	if(nbchoix==0){return NULL;}
	Maillonchoix* cc;
	cc = (Maillonchoix*)malloc(sizeof(Maillonchoix));
	fscanf(fe, "%s %s %d %d", cc->Ville, cc->dep, &cc->decision, &cc->validation);
	cc->suivant = lireCarte(fe, nbchoix-1);
	return cc;
}

listetuinfo lireEtu(FILE *fe){
 	listetuinfo b;
	int i;
	fscanf(fe, "%d %s %s %d %d %d %d %d", &b.numeroetu, b.nometu, b.prenometu, &b.notes[0], &b.notes[1], &b.notes[2], &b.notes[3], &b.nbchoix);
	return b;
}

int chargeretudiant(char nomFich[], listetuinfo *tetu[], int tmax){
	int i=0, nbetu;
	listetuinfo a;
	Listchoixdept b;
	FILE *fe;
	fe = fopen( nomFich, "r");
	if(fe==NULL){printf("<! pb ouverture fichier in chargeretudiant !>\n");return-1;}
	fscanf(fe, "%d", &nbetu);
	b = listvide();
	for(i=0; i<nbetu; i++){
		if(i==tmax){printf("<! erreur fichier in chargeetudiant !>");fclose(fe);return-1;}
		tetu[i] = (listetuinfo*)malloc(sizeof(listetuinfo));
		if(tetu[i]==NULL){printf("<! pb malloc in chargeretudiant !>\n");fclose(fe);return-1;}
		a = lireEtu(fe);
		b = lireCarte(fe, a.nbchoix);
		a.carte = b;
		*tetu[i] = a;
	}
	fclose(fe);
	return nbetu;
}

//rechercher etu ==============================================================================================================================================================

int recherdicoetu(listetuinfo *tetu[], int nb, int num){
	int d=0, m, f=nb-1;
	while(d<=f){
		m=(d+f)/2;
		if(tetu[m]->numeroetu==num){return m;}
		if(tetu[m]->numeroetu<num){
			f=m-1;
		}else{
			d=m+1;
		}
	}
	return -1;
}

//enregistrement ========================================================================================================================================================

void enregistrementcarte(FILE *fe, Maillonchoix* carte, int nb){
	if(carte==NULL){return;}
	fprintf(fe, "%s\n%s\n%d\n%d\n", carte->Ville, carte->dep, carte->decision, carte->validation);
	enregistrementcarte(fe, carte->suivant, nb-1);
	free(carte);
}

void enregistrementinfo(FILE *fe, listetuinfo *etu){
	Listchoixdept b;
	int i=0;
	b = etu->carte;
	fprintf(fe, "%d\n%s\n%s\n%d %d %d %d\n%d\n", etu->numeroetu, etu->nometu, etu->prenometu, etu->notes, etu->nbchoix);
	enregistrementcarte(fe, b, etu->nbchoix);
}

int enregistrementetudiants(char nomFich[], listetuinfo *tetu[], int nb){
	int i=0;
	FILE *fe;
	listetuinfo *etu;
	fe = fopen( nomFich, "w");
	if(fe==NULL){printf("<! pb fichier in enregistrementetudiant !>\n");return-1;}
	fprintf(fe, "%d\n", nb);
	for(i=0; i<nb; i++){
		etu = tetu[i];
		enregistrementinfo(fe, etu);
		free(tetu[i]);
	}
	fclose(fe);
}

//=============================================================================================================================================================================================================================

//affichage =======================================================================================================================================================

//affiche que les cartes d'une personne
void affichagecarte(Listchoixdept c){
	if(c==NULL){printf("\n");return;}
	printf("%s - %s\n \tdécision : %d\n \tvalidation : %d", c->Ville, c->dep, c->decision, c->validation);
	if(c->suivant==NULL){affichagecarte(c->suivant);}
	else{
		printf("\n - ");
		affichagecarte(c->suivant);
	}
}

//affiche que la personne
void affichageetu(listetuinfo a){
	printf(" %d\n %s %s\n", a.numeroetu, a.nometu, a.prenometu);
	printf(" mathématique : %d -", a.notes[0]);
	printf(" français : %d -", a.notes[1]);
	printf(" anglais : %d -", a.notes[2]);
	printf(" matière spé : %d\n", a.notes[3]);
}

//affichage general
void affichealletu(listetuinfo *tetu[], int nb){
	int j=0;
	Listchoixdept b;
	b = listvide();
	for(j=0; j<nb; j++){
		affichageetu(*tetu[j]);
		printf("tout les choix :\n - ");
		b = tetu[j]->carte;
		affichagecarte(b);
		printf("\n\n");
	}
}

//général fonction for ajouter modifier et supprimer ========================================================================================

int cherchelistcorrespond(MaillonDept* dep, char choixdep[]){
	if(dep==NULL){return -1;}
	if(strcmp(dep->departement,choixdep)==0){return 1;}
	return cherchelistcorrespond(dep->suivant, choixdep);
}


int correspondville(char choixville[], char choixdep[], VilleIUT *tville[], int nbville){
	int i, ok;
	Listdept b;
	for(i=0; i<nbville; i++){
		if(strcmp(tville[i]->Ville,choixville)==0){
			b = tville[i]->ldept;
			ok = cherchelistcorrespond(b, choixdep);
			if(ok==1){return 1;}
		}
	}
	return -1;
}

int correspondcarte(char choixville[], char choixdep[], Listchoixdept carte){
	if(carte==NULL){return 0;}
	if(strcmp(choixville,carte->Ville)==0){
		if(strcmp(choixdep,carte->dep)==0){
			return 1;
		}
	}
	correspondcarte(choixville, choixdep, carte->suivant);
}



//ajouter =============================================================================================================================================

void choix(VilleIUT *tville[], int nbville, char choixville[], char choixdep[]){
	int i, ok;
	printf("ville : \n");
	fgets(choixville, 31, stdin);
	choixville[strlen(choixville)-1]='\0';
	printf("departement : \n");
	fgets(choixdep, 31, stdin);
	choixdep[strlen(choixdep)-1]='\0';
	ok = correspondville(choixville, choixdep, tville, nbville);
	while(ok!=1){
		printf("ville : \n");
		fgets(choixville, 31, stdin);
		choixville[strlen(choixville)-1]='\0';
		printf("departement : \n");
		fgets(choixdep, 31, stdin);
		choixdep[strlen(choixdep)-1]='\0';
		ok = correspondville(choixville, choixdep, tville, nbville);
	}
}

Listchoixdept ajoutercarte(Maillonchoix* a, char choixville[], char choixdep[]){
	Maillonchoix* carte;
	carte = (Maillonchoix*)malloc(sizeof(Maillonchoix));
	if(carte==NULL){printf("<! erreur malloc in ajoutercarte !>\n");exit(1);}
	strcpy(carte->Ville,choixville);
	strcpy(carte->dep,choixdep);
	carte->decision=0;
	carte->validation=0;
	carte->suivant=a;
	return carte;
}

void allajoutprocess(VilleIUT *tville[], listetuinfo etu, int nbville){
	int i, ok;
	Listchoixdept b;
	b = etu.carte;
	char choixville[31], choixdep[31];
	affichageville(tville, nbville);
	choix(tville, nbville, choixville, choixdep);
	ok = correspondcarte(choixville, choixdep, b);
	if(ok==0){b = ajoutercarte(b, choixville, choixdep);}
	else{printf("\t< choix deja existant >\n");}
}// possible de devoir rerajouter b dans etu ??????????? et return nb+1

//modifier ==============================================================================================================================================================

void choix2(Listchoixdept lcarte, char choixville[], char choixdep[]){
	int ok;
	printf("ville : \n");
	fgets(choixville, 31, stdin);
	choixville[strlen(choixville)-1]='\0';
	printf("departement : \n");
	fgets(choixdep, 31, stdin);
	choixdep[strlen(choixdep)-1]='\0';
	ok = correspondcarte(choixville, choixdep, lcarte);
	while(ok!=1){
		printf("ville : \n");
		fgets(choixville, 31, stdin);
		choixville[strlen(choixville)-1]='\0';
		printf("departement : \n");
		fgets(choixdep, 31, stdin);
		choixdep[strlen(choixdep)-1]='\0';
		ok = correspondcarte(choixville, choixdep, lcarte);
	}
}

void fchoixdep(char choixville[], char choixdep[], VilleIUT *tville[], int nbville){
	int ok;
	printf("\n< quel departement voulez vous choisir ? >\n==>");
	fgets(choixdep, 31, stdin);
	choixdep[strlen(choixdep)-1]='\0';
	ok = correspondville(choixville, choixdep, tville, nbville);
	while(ok!=1){
		printf("\n< quel departement voulez vous choisir ? >\n==>");
		fgets(choixdep, 31, stdin);
		choixdep[strlen(choixdep)-1]='\0';
		ok = correspondville(choixville, choixdep, tville, nbville);
	}
}

Listchoixdept choixmodifcarte(Listchoixdept dep, char choixville[], char choixdep[], VilleIUT *tville[], int nbville){
	if(dep==NULL){exit(1);}
	if(strcmp(dep->Ville,choixville)==0){
		if(strcmp(dep->dep,choixdep)==0){
			fchoixdep(choixville, choixdep, tville, nbville);
			strcpy(dep->dep,choixdep);
			return dep;
		}
	}
	dep->suivant = choixmodifcarte(dep->suivant, choixville, choixdep, tville, nbville);
}

void affichagedep(MaillonDept* carte){
	if(carte==NULL){return;}
	printf("%s", carte->departement);
	affichagedep(carte->suivant);
}

void affichervillechoix(VilleIUT *villechoix){
	int i;
	Listdept ldep;
	ldep = villechoix->ldept;
	printf("%s :\n", villechoix->Ville);
	affichagedep(ldep);
	printf("\n");
}

int correspondvilleonly(char choixville[], VilleIUT *ville){
	Listdept b;
	if(strcmp(ville->Ville,choixville)==0){
		affichervillechoix(ville);
		return 1;
	}
}

void modificationcarte(listetuinfo etu, VilleIUT *tville[], int nbville){
	int i, ok;
	char choixville[31], choixdep[31];
	Listchoixdept lcarte;
	lcarte=etu.carte;
	affichagecarte(lcarte);
	choix2(lcarte, choixville, choixdep);
	for(i=0; i<nbville; i++){
		ok = correspondvilleonly(choixville, tville[i]);
		if(ok==1){
			fchoixdep(choixville, choixdep, tville, nbville);
			lcarte = choixmodifcarte(lcarte, choixville, choixdep, tville, nbville);
			etu.carte=lcarte;
		}
		else{printf("\t< choix deja existant >\n");}
	}
}

//supprimer ==========================================================================================================================================

Maillonchoix* suppressioncartechoix(char choixville[], char choixdep[], Listchoixdept carte){
	Maillonchoix *premier, *tmp;
	if(carte==NULL){exit(1);}
	if(strcmp(carte->Ville,choixville)==0){
		if(strcmp(choixdep,carte->dep)==0){
			tmp=carte->suivant;
			free(carte);
			return tmp;
		}
	}
	carte = suppressioncartechoix(choixville, choixdep, carte->suivant);
}

void suppcarte(listetuinfo *etu){
	int i, ok;
	char choixville[31], choixdep[31];
	Listchoixdept lcarte;
	lcarte = etu->carte;
	affichagecarte(lcarte);
	choix2(lcarte, choixville, choixdep);
	lcarte = suppressioncartechoix(choixville, choixdep, lcarte);
}// return nb -1

//=========================================================================================================================================================

// zone de test =========================================================================================

void test1(void){
	listetuinfo *tetu[5000];
	int nb;
	char nomFich[20];
	strcpy( nomFich, "candidature.txt");
	nb = chargeretudiant(nomFich, tetu, 5000);
	affichealletu(tetu, nb);
}

//==========================================================================================================

// Partie 3




































// Partie 4

/*
	V affichage coté candidat de ces infos admis ou pas
	- valdier ça candidature refuse les autres
	- valider met a jour le dossier candidature
	- chaque departement peut consulter ça liste d'attente
	- metre a jour la liste 
	-
	-
	-
	-
	-

*/

// coté etu=========================================================================================================
// affichage
/*
void affichagedepresultat(Maillonchoix* carte){
	if(carte==NULL){return;}
	if(carte->decision==1){
		printf("%s %s - admis \n", carte.Ville, carte.dep);
	}
	if(carte->decision==1){
		printf("%s %s - refusé \n", carte.Ville, carte.dep);
	}
	if(carte->decision==1){
		printf("%s %s - lsite d'attente \n", carte.Ville, carte.dep);
	}
	affichagedepresultat(carte.suivant);
}

// validation 

void validation(char choixville[], char choixdep[], Maillonchoix* carte, int *ok, Maillonatt lplace, int nbplace, listetuinfo etu){
	if(carte==NULL){return;}
	if(strcmp(carte.Ville,choixville)==0){
		if(strcmp(carte.dep,choixdep)==0){
			if(carte.decision==1){
				carte.validation=1;
				*ok=1;
			}else{printf("vous netes pas admis dans cette iut\n");*ok=-1;return;}
		}
	}
	validation(choixville, choixdep, carte.suivant, ok);
	if(ok==1){
		if(carte.decision==1){
			carte.validation=-1;
			miseajourindep( lplace, nbplace, etu);
		}
	}
}

void enregistrementvalidation(char choixville[], char choixdep[], Maillonchoix* carte, int *ok, char nomFich[], listetuinfo *tetu[], int nb){
	int ok;
	validation( choixville, choixdep, carte, &ok);
	enregistrementetudiants( nomFich, tetu, nb);
}

// -> mise a jour 

Maillonatt miseajourfile(Maillonatt place, int nbplace, listetuinfo etu){
	if(place==NULL){exit(1);}
	if(place.munc==etu.numeroetu){
		Maillonatt temp;
		temp=place.suivant;
		free(place);
		return temp;
	}
	miseajourfile(place.suivant, nbplace-1);
}

int miseajouratt(Maillonatt place, int nbplace){
	if(place==NULL){return;}
	if(nbplace==0){return;}
	if(place.decision==2){
		place.decision==1;
	}
	miseajouratt(place.suivant, nbplace-1);
}

void miseajourindep(Maillonatt lplace, int nbplace, listetuinfo etu){
	lpace = miseajourfile(lplace, nbplace, etu);
	miseajouratt(lplace, nbplace);
}



// coté dep=============================================================================================================
// affichage dep 

void affichageonlyadmis(Maillonatt etuatt){
	if(etuatt==NULL){return;}
	if(etuatt.decision==1){
		printf("%d %s %s\n" etuatt.numc, etuatt.nom, etuatt.prenom);
	}
	affichageonlyadmis(etuatt.suivant);
}

void affichageonlyatt(Maillonatt etuatt){
	if(etuatt==NULL){return;}
	if(etuatt.decision==1){
		printf("%d %s %s\n" etuatt.numc, etuatt.nom, etuatt.prenom);
	}
	affichageonlyatt(etuatt.suivant);
}

//chercher present en admission ========================================================================================

void chercheretuadmisindep(char choixnom[], char nomprenom[], Maillonatt etuatt){
	if(etuatt==NULL){printf("erreur de recherche\n");return;}
	if(strcmp(etuatt.nom,choixnom)==0){
		if(strcmp(etuatt.prenom,choixprenom)==0){
			if(etuatt.decision==1){printf("%s %s est admis\n", etuatt.nom, etuatt.prenom);return;}
			if(etuatt.decision==2){printf("%s %s est en attente\n", etuatt.nom, etuatt.prenom);return;}
			if(etuatt.decision==-1){printf("%s %s est refusé\n", etuatt.nom, etuatt.prenom);return;}
		}
	}
	chercheretuadmisindep(choixnom, choixprenom, etuatt.suivant);
}
*/
// Général (menu et ce qui en ai relié)
/*
questionadmin(){
	printf("\nQuel numéro détudiant ?\n==>");	
	scanf("%d%*c", &choix);
	printf("\n");
}

int menu(void){


//charger


	int i=0, choix;
	while(i!=1){
		printf("\n\tmenu\n\n");
		printf("1\tutilisateur\n");
		printf("2\tadmin\n");
		printf("3\tresponsable d'admission\n");
		printf("\nQuel est votre choix ?\n==>");	
		scanf("%d%*c", &choix);
		printf("\n");
		if(choix==1){
		}
		if(choix==2){
		}
		if(choix==3){
		}
		if(choix<1 || choix>6){
			printf("mauvaise saisie\n");
		}
	}

//enregister

	return 1;
}
*/