<?php require_once __ROOT__.'/manager/security.php';

/* INCLUSION DES REPOs */
// require_once __ROOT__.'/manager/repo/user.php';  // gestion des utilisateurs (UID, infos, création, modification)
// require_once __ROOT__.'/manager/repo/group.php'; // gestion des groupes & appartenances (UID, ajouter membres, visu membres, création, modification)
// require_once __ROOT__.'/manager/repo/semestre.php';
// require_once __ROOT__.'/manager/repo/module.php';
// require_once __ROOT__.'/manager/repo/ue.php';
// require_once __ROOT__.'/manager/repo/controle.php';
// require_once __ROOT__.'/manager/repo/note.php';
// debug();

class DBAccess{};

class DataBase{
	
	/* ATTRIBUTS */
	private $host;
	private $dbname;
	private $username;
	private $password;

	private static $pdo;

	private static $instance; 

	public function __construct($host, $dbname, $username, $password){
		$this->host     = $host;
		$this->dbname   = $dbname;
		$this->username = $username;
		$this->password = $password;
		
		// password: Qt358nUdyeTxLDM8
		DataBase::$pdo = new PDO('mysql:host='.$host.';dbname='.$dbname, $username, $password);
	}


	/* retourne une instance de la classe */
	public static function getInstance(){
		if( DataBase::$instance == null ){
			if( $_SERVER['HTTP_HOST'] == 'sid' ) // si co en local (xdrm)
				DataBase::$instance = new DataBase("localhost", "sid2", "php", "Qt358nUdyeTxLDM8");
			else if( $_SERVER['HTTP_HOST'] == 'localhost' ) // si co en local (autres)
				DataBase::$instance = new DataBase("localhost", "sid2", "root", "");
			else // si co en ligne
				DataBase::$instance = new DataBase("mysql.hostinger.fr", "u712664263_sid", "u712664263_php", "Qt358nUdyeTxLDM8");
		}
		
		return DataBase::$instance;
	}

	/* retourne la connection statique */
	public static function getPDO(){
		$instance = DataBase::getInstance();
		return DataBase::$pdo;
	}


/*************************************************************/
/*      _____ ______ _   _ ______ _____            _         */
/*     / ____|  ____| \ | |  ____|  __ \     /\   | |        */
/*    | |  __| |__  |  \| | |__  | |__) |   /  \  | |        */
/*    | | |_ |  __| | . ` |  __| |  _  /   / /\ \ | |        */
/*    | |__| | |____| |\  | |____| | \ \  / ____ \| |____    */
/*     \_____|______|_| \_|______|_|  \_\/_/    \_\______|   */
/*                                                           */
/*************************************************************/

	/* SUPPRIME LES VALEURS À CLÉS NUMÉRIQUES DANS UN FETCH D'UNE TABLE DE LA BDD
	*
	* @fetchData<Array>					le résultat d'une $requeteSQL->fetchAll()
	*
	* @return newFetchData<Array>		retourne le tableau donné en paramètre mais sans les valeurs à clés numériques	
	*
	*/
	public static function delNumeric($fetchData, $oneDimension=false){

		/* [1] 2 dimensions
		===============================================*/
		if( !$oneDimension ){

		// on supprime les doublons des entrées (indice numérique)
		for( $i = 0 ; $i < count($fetchData) ; $i++ ) // pour tout les utilisateurs
			foreach($fetchData[$i] as $col => $val){  // pour toutes les entrées
				
				if( !mb_detect_encoding($val, 'UTF-8') )
					$fetchData[$i][$col] = utf8_encode($val);
				
				if( is_int($col) )                    // si l'indice est un entier
					unset( $fetchData[$i][$col] );    // on le supprime
			}

		/* [2] 1 dimensions
		===============================================*/
		}else{

			// on supprime les doublons des entrées (indice numérique)
			foreach($fetchData as $i=>$val){  // pour toutes les entrées
				
				if( !mb_detect_encoding($val, 'UTF-8') )
					$fetchData[$i] = utf8_encode($val);

				if( is_int($i) )                    // si l'indice est un entier
					unset( $fetchData[$i] );    // on le supprime
			}

		}

		return $fetchData;
	}


	public function getSemestreInfoFromTime($time){
		$now = date('Y-m-d', $time);

		/* On cherche si l'année en cours est définie et on y est */
		$req = DataBase::getPDO()->prepare("SELECT *
			FROM semestrepair
			WHERE :now BETWEEN debut AND FIN");
		$req->execute(array( ':now' => $now ));
		$res = $req->fetch();

		/* Résultat bon, on le retourne */
		if( is_array($res) )
			return array('annee' => $res['annee'], 'semestre_pair' => $time >= strtotime($res['milieu']) );

		/* Sinon, on recherche la dernière année entrée dans la BDD */
		else{
			$req2 = DataBase::getPDO()->query("SELECT *
				FROM semestrepair
				WHERE annee in (select max(annee) from semestrepair);");
			$res2 = $req2->fetch();

			/* Résultat bon, on le retourne */
			if( is_array($res2) )
				return array('annee' => $res2['annee'], 'semestre_pair' => $time >= strtotime($res2['milieu']) );

			/* Sinon on retourne la valeur par défaut */
			else{
				$semestre_pair = Date('m', $time) < 8;
				$annee = ($semestre_pair) ? Date('Y', $time)-1 : Date('Y', $time);
				return array('annee' => "".$annee, 'semestre_pair' => $semestre_pair );
			}
		}
	}
	
		
/*********************************************************************************/
/*                               __  __  ____ ____                               */
/*                              |  \/  |/ ___/ ___|                              */
/*                              | |\/| | |  | |                                  */
/*                              | |  | | |__| |___                               */
/*                              |_|  |_|\____\____|                              */
/*                                                                               */
/*********************************************************************************/
	
	/* intègre un MCC à la BDD
	*
	* @semestre<int>			l'UID du semestre concerné
	* @mcc<Array>				contient toutes les données du MCC
	*
	*/
	public function setMCC($semestre, $mcc){

		foreach($mcc as $ue){
			$mcc_ue = ueRepo::forMCC($semestre, $ue->nom, $ue->libelle, $ue->coefficient);


			foreach($ue->modules as $module){
				$mcc_module = moduleRepo::forMCC($mcc_ue, $module->nom, $module->libelle, $module->coefficient);


				foreach($module->controles as $controle)
					$controle_uid = controleRepo::forMCC($mcc_module, $controle->nom, $controle->libelle, $controle->coefficient);


			}


		}

	}

	
	/* clone les MCC de la dernière année à l'année donnée
	*
	* @annee<int>				L'année de destination
	*
	* @return status<String>	"success" si tout s'est bien passé, sinon code erreur
	*
	*/
	public function cloneMCC($annee){
		// on récupère la dernière année à être référencée, si aucun résultat, on retourne une erreur
		if( !($srcYear=semestreRepo::getLastMCCYear()['annee']) ) return 'no_mcc_found';

		// année de destination
		$dstYear = $annee;


		/* [1] Pour chaque SEMESTRE de l'année
		============================================*/
		$listSemestre = semestreRepo::forYear($srcYear);
		foreach($listSemestre as $SEMESTRE){
			// on clone le semestre pour la nouvelle année
			$newSemestreUID = semestreRepo::creer($SEMESTRE['formation'], $SEMESTRE['nom_formation'], $SEMESTRE['nom'], $SEMESTRE['rang'], $dstYear);

			/* [2] Pour chaque UE de ce semestre
			============================================*/
			$listUE = ueRepo::forYear($SEMESTRE['id']);
			foreach($listUE as $UE){
				// on clone le mcc_ue mais pour le nouveau semestre
				$newUEUID = ueRepo::forMCC($newSemestreUID, $UE['nom'], $UE['libelle'], $UE['coefficient']);

				/* [3] Pour chaque MODULE de cet UE
				============================================*/
				$listModule = moduleRepo::forYear($UE['id'], $SEMESTRE['id']);
				foreach($listModule as $MODULE){
					// on clone le mcc_module mais pour le nouvel mcc_ue
					$newModuleUID = moduleRepo::forMCC($newUEUID, $MODULE['nom'], $MODULE['libelle'], $MODULE['coefficient']);

					/* [4] Pour chaque CONTRÔLE de ce module
					============================================*/
					$listControle = controleRepo::forYear($MODULE['id'], $SEMESTRE['id']);
					foreach($listControle as $CONTROLE){
						// on duplique le contrôle mais pour le nouveau mcc_module
						$newControleUID = controleRepo::forMCC($newModuleUID, $CONTROLE['nom'], $CONTROLE['libelle'], $CONTROLE['coefficient']);

					}

				}

			}
			
		}


		// tout s'est bien déroulé si on est arrivé jusque là
		return 'success';

	}


	/* intègre une liste d'utilisateurs (pour un rang d'une année) à la BDD
	*
	* @rang<int>				le rang du semestre en question
	* @annee<int>				l'année du semestre en question
	* @formationList<Array>		contient tous les étudiants par formations
	*
	*/
	public function addUserlist($rang, $annee, $formationList){

		foreach($formationList as $form){

			$formationUID = semestreRepo::includeFormation($form->nom, $form->libelle); // on récupère l'UID de la formation en la créant si nécessaire

			if( is_numeric($formationUID) ){ // si la formation est ok, alors on cherche le semestre
				
				$semestreUID  = semestreRepo::includeSemestre($rang, $annee, $formationUID);    // on récupère l'UID du semestre en le créant si nécessaire

				if( is_numeric($semestreUID) ){ // si le semestre est ok, alors on ajoute les utilisateurs

					foreach($form->userlist as $user){
						// on récupère l'UID utilisateur en le créant si nécessaire
						$utilisateurUID = userRepo::includeEtudiant($user->identifiant, $user->prenom, $user->nom, $user->sexe, $user->mail);

						if( is_string($utilisateurUID) ) // si l'utilisateur est ok, alors on créé l'appartenance
							groupRepo::includeAppartenance($utilisateurUID, $semestreUID); // on ajoute l'utilisateur au groupeVide de chaque semestre (s'il n'a pas déjà un groupe)
					}

				}

			}

		}

	}


	/* créé un semestre/formation dans la BDD
	*
	* @codeFormation<String>			le code/nom de la formation
	* @nomFormation<String>				le libellé de la formation
	* @nomSemestre<String>				le nom/libellé du semestre
	* @rangSemestre<int>				le rang du semestre dans la formation
	* @annee<int>						l'année du semestre
	*
	*
	* @return cree<Boolean>				retourne VRAI si les éléments existaient ou ont bien été créés
	*
	*/
	public function creerSemestre($codeFormation, $nomFormation, $nomSemestre, $rangSemestre, $annee){
		// si on a tout créé ou que tout existe "creer" retourne l'UID du semestre,
		// si on a un boolean c'est FALSE => erreur

		if( !is_bool(semestreRepo::creer($codeFormation, $nomFormation, $nomSemestre, $rangSemestre, $annee)) )
			return true;
		else
			return false;
	}


	/* effectue la capitalisation de l'ue
	* @ue pour le semestre @semestre
	* pour l'étudiant @etudiant
	*/
	public function capitaliserUE($ue, $semestre, $etudiant){
		// on vérifie l'existence des paramètres (etudiant, semestre, ue)
		if( !semestreRepo::exists($semestre) )             return 'unknown_semestre';
		if( !groupRepo::forStudent($etudiant, $semestre) ) return 'unknown_user';
		if( !($ueInfo=ueRepo::info($ue)) )                 return 'unknown_ue';

		// on vérifie que ce semestre a bien l'ue donnée
		$UEs = ueRepo::forStudent($etudiant, $semestre);
		$UEUIDList = array();

		foreach($UEs as $UE)
			if( !in_array($UE['id'], $UEUIDList) )
				array_push($UEUIDList, $UE['id']);

		// si l'UE n'est pas dans ce semestre, on retourne une erreur
		if( !in_array($ue, $UEUIDList) ) return 'unknown_ue';


		/* [1] On récupère les redoublements de ce semestre
		======================================================*/
		$redoublements = semestreRepo::getRedoublements($semestre, $etudiant);

		/* [2] On retire ceux qui n'ont pas l'UE
		======================================================*/
		foreach($redoublements as $iter_s=>$SEM){
			$listeUEs = ueRepo::forStudent($etudiant, $SEM['id_semestre']);
			$hasUE = false;
			// on vérifie que le semestre a bien l'UE
			foreach($listeUEs as $UE)
				if( $UE['id'] == $ue ) $hasUE = true;
			
			// s'il n'a pas l'UE, on le supprime
			if( !$hasUE ) unset($redoublements[$iter_s]);
		}

		/* [3] On applique les modifications
		======================================================*/
		$checker = true;
		// on définit l'UE comme actif
		$checker = $checker && ueRepo::capitalisation($semestre, $etudiant, $ue, true);

		// on définit l'UE dans les autres semestres comme inactif
		foreach($redoublements as $red)
			$checker = $checker && ueRepo::capitalisation($red['id_semestre'], $etudiant, $ue, false);


		return ($checker) ? 'success' : 'error';

	}


/*************************************************************************************/
/*     _    _ _______ _____ _      _____  _____      _______ ______ _    _ _____     */
/*    | |  | |__   __|_   _| |    |_   _|/ ____|  /\|__   __|  ____| |  | |  __ \    */
/*    | |  | |  | |    | | | |      | | | (___   /  \  | |  | |__  | |  | | |__) |   */
/*    | |  | |  | |    | | | |      | |  \___ \ / /\ \ | |  |  __| | |  | |  _  /    */
/*    | |__| |  | |   _| |_| |____ _| |_ ____) / ____ \| |  | |____| |__| | | \ \    */
/*     \____/   |_|  |_____|______|_____|_____/_/    \_\_|  |______|\____/|_|  \_\   */
/*                                                                                   */
/*************************************************************************************/


	/*********************************************/
	/*** création d'un utilisateur dans la bdd ***/
	/*********************************************/
	public function creerUtilisateur($identifiant, $prenom, $nom, $mail, $mdp, $droits){
		if( userRepo::creer($identifiant, $prenom, $nom, $mail, $mdp, $droits) ) // si l'utilisateur a bien été créé
			return 'success';
		else
			return 'error';
	}


	/*********************************************************************************/
	/*** on récupère les informations utiles à l'utilisateur lors de la connection ***/
	/*********************************************************************************/
	public function utilisateurInfo($identifiant){
		// on vérifie que l'utilisateur existe
		if( !($utilisateurUID=userRepo::UID($identifiant)) ) return 'unknown_user';

		return userRepo::info($utilisateurUID);
	}


	/* retourne le semestre en cours d'un étudiant
	*
	* @etudiant<String>				L'identifiant (UID) de l'étudiant en question
	* @semestre_pair<Boolean>		VRAI si le rang semestre est pair, sinon FAUX
	* @annee<int>					L'année scolaire en cours
	*
	* @return semestreUID<int>		l'UID du semestre courant 
	* 
	*/
	public static function studentSemestre($etudiant, $semestre_pair, $annee){
		if( !($semestre=semestreRepo::forStudent($etudiant, $semestre_pair, $annee)) ) // si on a un résultat
			return 'error';
		else
			return $semestre;
	}


	/* retourne la liste des enseignants de la BDD
	*
	* @admin<String>					l'UID de l'admin qui demande ça
	* 
	*
	* @return enseignants<Array>		retourne la liste des enseignants de la bdd
	*
	*/
	public function listeUtilisateursRole($annee){
		$roleUsers = userRepo::getRoleUsers();

		foreach($roleUsers as $iter=>$user){
			$semestreList = $this->getModulesByUEByEnseignant($user['id'], null, $annee);
			if( is_array($semestreList) ) $roleUsers[$iter]['semestreList'] = $semestreList;
			else                          $roleUsers[$iter]['semestreList'] = null;
		}

		return $roleUsers;
	}


	/* retourne la liste des semestres de la BDD par annnées
	*
	* @return annees<Array>				retourne la liste des années contenant chacunes leurs semestres
	*
	*/
	public function getListeSemestres(){
		$listeAnnees = semestreRepo::getAnnees();

		foreach($listeAnnees as $iter_a=>$annee){

			$listeAnnees[$iter_a]['semestres'] = semestreRepo::forYear($annee['annee']);
			
			foreach($listeAnnees[$iter_a]['semestres'] as $iter_s=>$semestre)
				$listeAnnees[$iter_a]['semestres'][$iter_s]['nb_etudiants'] = semestreRepo::nbEtuForSemestre($semestre['id']);

		}

		return $listeAnnees;
	}


	/* modifie le caractère "admin" d'un utilisateur
	*
	* @utilisateur<String>				l'UID de l'utilisateur en question
	* @admin<Boolean>					VRAI si admin, FAUX sinon
	*
	*
	* @return updated<Boolean>			VRAI si la modification a été faite
	*
	*/
	public function setAdmin($utilisateur, $admin){
		// on vérifie l'existence de l'utilisateur
		if( !($utilisateurUID=userRepo::UID($utilisateur)) ) return 'unknown_user';

		return userRepo::setAdmin($utilisateurUID, $admin);
	}


	/* modifie le caractère "référent" d'un utilisateur
	*
	* @utilisateur<String>				l'UID de l'utilisateur en question
	* @master<Boolean>					VRAI si master, FAUX sinon
	*
	*
	* @return updated<Boolean>			VRAI si la modification a été faite
	*
	*/
	public function setMaster($utilisateur, $master){
		// on vérifie l'existence de l'utilisateur
		if( !($utilisateurUID=userRepo::UID($utilisateur)) ) return 'unknown_user';

		return userRepo::setMaster($utilisateurUID, $master);
	}


	/* ajoute un module qu'un utilisateur peut corriger
	*
	* @utilisateur<String>				l'UID de l'utilisateur en question
	* @mccmodule<int>					l'UID du mcc_module à ajouter
	* 
	* @groupe<int>						***OPTIONNEL*** l'UID du groupe à ajouter
	*
	*
	* @return added<Boolean>			VRAI si module ajouté, sinon FALSE
	*
	*/
	public function correcteurAjouterModule($utilisateur, $mccmodule, $groupe=null){
		// on vérifie l'existence de l'utilisateur et du groupe
		if( !($utilisateurUID=userRepo::UID($utilisateur)) ) return 'unknown_user';
		
		if( $groupe != null ) // si un groupe est donné, on le cherche
			if( !($groupeUID=groupRepo::info($groupe)['id']) )   return 'unknown_group';


		// si on ajoute pour un groupe donné, on le fait
		if( $groupe != null ){
			$success = userRepo::addModule($utilisateurUID, $mccmodule, $groupeUID);

		// si aucun groupe n'est donné
		}else{

			$inscrits = groupRepo::inscritsMccModule($mccmodule);
			$success = true;
			foreach($inscrits as $groupe)
				$success = $success && userRepo::addModule($utilisateurUID, $mccmodule, $groupe['id']);

		}


		// définit l'utilisateur comme enseignant et retourne le statut
		return $success && userRepo::setTeacher($utilisateurUID);

	}


	/* supprime un module qu'un utilisateur peut corriger
	*
	* @utilisateur<String>				l'UID de l'utilisateur en question
	* @mccmodule<int>					l'UID du mcc_module à supprimer
	*
	* @groupe<int>						***OPTIONNEL*** l'UID du groupe à supprimer
	* 
	*
	* @return removed<Boolean>			VRAI si module supprimé, sinon FALSE
	*
	*/
	public function correcteurSupprimerModule($utilisateur, $mccmodule, $groupe=null){
		// on vérifie l'existence de l'utilisateur
		if( !($utilisateurUID=userRepo::UID($utilisateur)) ) return 'unknown_user';
		
		if( $groupe != null ) // si un groupe est donné, on le cherche
			if( !($groupeUID=groupRepo::info($groupe)['id']) )   return 'unknown_group';


		// si on ajoute pour un groupe donné, on le fait
		if( $groupe != null )
			$success = userRepo::delModule($utilisateurUID, $mccmodule, $groupeUID);


		// si aucun groupe n'est donné
		else{

			$inscrits = groupRepo::inscritsMccModule($mccmodule);
			$success = true;
			foreach($inscrits as $groupe)
				$success = $success && userRepo::delModule($utilisateurUID, $mccmodule, $groupe['id']);
			
		}

		// définit l'utilisateur comme enseignant et retourne le statut
		return $success && userRepo::setTeacher($utilisateurUID);

	}

/**********************************************************/
/*     _____ _____   ____  _    _ _____  ______  _____    */
/*    / ____|  __ \ / __ \| |  | |  __ \|  ____|/ ____|   */
/*   | |  __| |__) | |  | | |  | | |__) | |__  | (___     */
/*   | | |_ |  _  /| |  | | |  | |  ___/|  __|  \___ \    */
/*   | |__| | | \ \| |__| | |__| | |    | |____ ____) |   */
/*    \_____|_|  \_\\____/ \____/|_|    |______|_____/    */
/*                                                        */
/**********************************************************/


	/****************************************/
	/*** création d'un groupe dans la bdd ***/
	/****************************************/
	public function creerGroupe($nom){
		if( groupRepo::creer($nom) ) // si on a bien ajouté un entrée ou qu'elle n'existait pas déjà
			return 'success';
		else
			return 'error';
	}

	/******************************************************/
	/*** ajout d'un utilisateur à un groupe dans la bdd ***/
	/******************************************************/
	public function ajouterEtudiantGroupe($etudiant, $groupe, $semestre, $annee){
		// on vérifie que l'utilisateur, le groupe, le semestre existent
		if( !($etudiantUID=userRepo::UID($etudiant)) ) return 'unknown_user';
		if( !($groupeUID=groupRepo::UID($groupe)) ) return 'unknown_group'; else $groupeUID = (int) $groupeUID;
		if( !($semestreUID=semestreRepo::UID($semestre, $annee)) ) return 'unknown_semestre'; else $semestreUID = (int) $semestreUID;


		if( groupRepo::ajouterMembre($etudiantUID, $groupeUID, $semestreUID) ) // si on a bien ajouté un entrée
			return 'success';
		else
			return 'error';
	}

	/******************************************************************/
	/*** retourne la liste des utilisateurs du groupe d'un étudiant ***/
	/******************************************************************/
	public function listeEtudiantsGroupe($etudiant, $semestre){
		// on vérifie que le groupe et le semestre existent
		if( !semestreRepo::exists($semestre) ) return 'unknown_semestre';
		else $semestreUID = $semestre;
		
		if( !($etudiantUID=userRepo::UID($etudiant, $semestreUID)) ) return 'unknown_user';
		if( !($groupeObj=groupRepo::forStudent($etudiantUID, $semestreUID)) ) return 'unknown_group';

		$userlist = DataBase::delNumeric( groupRepo::membres($groupeObj['id'], $semestreUID) );
		$userlist['groupe'] = $groupeObj['nom'];
		// foreach($userlist as $iter=>$user)
		// 	$userlist[$iter]['groupe'] = $groupeObj['nom'];

		// on retourne la liste des utilisateurs et on supprime les doublons à indices numériques
		return $userlist;

	}

	/********************************************************************/
	/*** retourne la liste des utilisateurs des groupes d'un semestre ***/
	/********************************************************************/
	public function listeEtudiantsTousGroupesSemestre($semestre){
		// on vérifie que le semestre existe
		if( !semestreRepo::exists($semestre) ) return 'unknown_semestre';
		else $semestreUID = $semestre;

		$grouplist = groupRepo::forSemestre($semestreUID); // contiendra tout les groupes

		// on parcourt tous les groupes
		foreach($grouplist as $iter=>$val)
			$grouplist[$iter]['userlist'] = groupRepo::membres($grouplist[$iter]['id'], $semestreUID); // on charge la liste des utilisateurs de ce groupe
		
		return $grouplist; // sinon on retourne le tableau

	}

	/******************************************************************/
	/*** retourne la liste des utilisateurs des groupes d'une année ***/
	/******************************************************************/
	public function listeEtudiantsTousGroupesAnnee($annee, $semestre_pair){
		// on récupère la liste des groupes
		$grouplist = groupRepo::forYear($semestre_pair, $annee);

		foreach($grouplist as $iter=>$val) // pour chaque groupe un récupère la liste des utilisateurs
			$grouplist[$iter]['userlist'] = groupRepo::membres($grouplist[$iter]['id'], $grouplist[$iter]['id_semestre']);

		return $grouplist; // sinon on retourne le tableau

	}

	/******************************************************************/
	/*** retourne la liste des utilisateurs des groupes d'une année ***/
	/******************************************************************/
	public function listeEtudiantsTousGroupesEnseignant($annee, $semestre_pair, $enseignant){
		/*** on cherche un semestre avec cette année ***/
		$checkAnnee = DataBase::getPDO()->prepare("SELECT id_semestre as id FROM semestre WHERE annee = :annee");
		$checkAnnee->execute(array( ':annee' => $annee ));
		if( !( $checkAnnee->fetch()['id'] ) ) return 'unknown_year';

		// on cherche si cet enseignant enseigne un semestre courant de cette année
		if( !($enseignantUID=userRepo::UID($enseignant, null, $semestre_pair, $annee)) ) return 'unknown_teacher';


		// on récupère la liste des groupes
		$grouplist = DataBase::delNumeric( groupRepo::forTeacher($enseignantUID, $semestre_pair, $annee) );

		foreach($grouplist as $iter=>$val) // pour chaque groupe un récupère la liste des utilisateurs
			$grouplist[$iter]['userlist'] = groupRepo::membres($grouplist[$iter]['id'], $grouplist[$iter]['id_semestre']);

		return $grouplist; // sinon on retourne le tableau
	}


	/****************************************************************/
	/***** déplace une liste d'étudiants d'un groupe à un autre *****/
	/****************************************************************/
	public function deplacerEtudiantMultiple($etudiants, $groupe, $semestre){

		// on vérifie que le semestre et que le groupe de destination existent
		if( !($semestreInfo=semestreRepo::info($semestre)) ) return 'unknown_semestre';
		if( !($destGroupeInfo=groupRepo::info($groupe))    ) return 'unknown_newgroup';

		foreach($etudiants as $etu)
			if( !(groupRepo::ajouterMembre($etu, $destGroupeInfo['id'], $semestreInfo['id'])) )
				return 'error';

		return 'success';
	}


	/* retourne la liste exhaustive des groupes de la BDD
	*
	* @return grouplist<Array>				la liste de tous les groupes de la BDD
	*
	*/
	public function getExhaustiveGroupList(){
		$grouplist = groupRepo::getAllGroups();

		// on essaie de supposer le semestre en fonction du nom
		foreach($grouplist as $i=>$group)
			if( preg_match('/^(?:.+)?S(\d)(?:.+)?$/', $group['nom'], $m) ) // si le semestre est dans le nom
				$grouplist[$i]['rang'] = intval($m[1]); // on récupère le rang
			else
				$grouplist[$i]['rang'] = null;        // sinon rang = null


		return $grouplist;
	}


	/* Applique les mentions du jury aux étudiants d'un semestre
	*
	* @semestre<int>					UID du semestre en question
	* @jury<Array>						Tableau contenant les étudiants et leurs mention
	*
	*
	* @return success<Boolean>			Retourne VRAI si aucune erreur n'occure, sinon retourne FAUX
	* 
	*/
	public function applyJurySemestre($semestre, $jury){
		$state = true;
		foreach($jury as $ETU){
			$state = $state && DataBase::getInstance()->applyJuryTo($ETU->etudiant, $semestre, $ETU->mention) == 'success';
		}

		return $state;
	}


	/* Applique la mention du jury à un étudiant d'un semestre
	*
	* @etudiant<String>						UID de l'étudiant en question
	* @semestre<int>						UID du semestre courant de l'étudiant
	*
	*
	* @return state<String>					SUCCESS => changement effectué
	*                                   			OU fin de formation
	*                                   	*       => ERREUR
	*
	* ADM => Passage de semestre (admis)
	* ADJ => Passage de semestre (admis pas jury)
	* ATT => Passage de semestre (si rang impair) SINON redoublement
	* NAR/DEM/AJ => Pas pris
	*/
	public function applyJuryTo($etudiant, $semestre, $mention){

		// on vérifie que le semestre existe et que l'étudiant est inscrit à ce semestre
		if( !($semestreInfo=semestreRepo::info($semestre)) ) return 'unknown_semestre';
		if( !($etudiantUID=userRepo::UID($etudiant, $semestre)) ) return 'unknown_user';

		// on vérifie que la mention est correcte
		if( !in_array($mention, array('ADM', 'ADJ', 'ATT', 'NAR', 'DEM', 'AJ')) ) return 'unknown_mention';

		/* [1] On définit la mention pour l'utilisateur à ce semestre
		======================================================*/
		groupRepo::setMention($etudiantUID, $semestre, $mention);

		/* [2] Gestion du passage de l'étudiant
		======================================================*/
		// si ADM/ADJ ou RDB (redoublement) et semestre impair, passage
		if( in_array($mention, array('ADM', 'ADJ')) || $mention == 'ATT' && $semestreInfo['rang']%2==1 ){
			/* (1) On récupère le semestre suivant s'il existe */
			$nextSemestre = semestreRepo::next($semestre);

			/* (2) Si le semestre n'existe pas, on le créé */
			if( is_array($nextSemestre) )
				$nextSemestre = semestreRepo::creer($semestreInfo['formation'], $semestreInfo['nom_formation'], null, $nextSemestre['rang'], $nextSemestre['annee']);
			
			// si le semestre n'est toujours pas créé, on retourne une erreur
			if( is_bool($nextSemestre) ) return 'error';

			/* (3) On créé l'appartenance */
			$appartenanceUID = groupRepo::includeAppartenance($etudiant, $nextSemestre);

		/* [3] Gestion du redoublement (début année), rang-2
		======================================================*/
		}elseif( $mention == 'ATT' ){
			/* (1) On récupère le semestre précédent */
			$rdbSemestre = semestreRepo::prev($semestre);

			/* (2) Si le semestre n'existe pas, on le créé */
			if( is_array($rdbSemestre) )
				$rdbSemestre = semestreRepo::creer($semestreInfo['formation'], $semestreInfo['nom_formation'], null, $rdbSemestre['rang'], $rdbSemestre['annee']);
			
			// si le semestre n'est toujours pas créé, on retourne une erreur
			if( is_bool($rdbSemestre) ) return 'error';

			/* (3) On créé l'appartenance */
			$appartenanceUID = groupRepo::includeAppartenance($etudiant, $rdbSemestre);
		}

		// if( isset($nextSemestre)    ) var_dump('nxt: '.$nextSemestre);
		// if( isset($rdbSemestre)     ) var_dump('rdb: '.$rdbSemestre);
		// if( isset($appartenanceUID) ) var_dump('app: '.$appartenanceUID);
		return 'success';
	}


/**********************************************************/
/*                                                        */ 
/*    __  __  ____  _____  _    _ _      ______  _____    */
/*   |  \/  |/ __ \|  __ \| |  | | |    |  ____|/ ____|   */
/*   | \  / | |  | | |  | | |  | | |    | |__  | (___     */
/*   | |\/| | |  | | |  | | |  | | |    |  __|  \___ \    */
/*   | |  | | |__| | |__| | |__| | |____| |____ ____) |   */
/*   |_|  |_|\____/|_____/ \____/|______|______|_____/    */
/*                                                        */
/**********************************************************/


	/**************************************************/
	/*** retourne les modules d'un étudiant par UEs ***/
	/**************************************************/
	public function getModulesByUEByEtudiant($etudiant, $semestre){
		// on vérifie que le semestre et l'utilisateur existent
		if( !semestreRepo::exists($semestre) ) return 'unknown_semestre';
		else $semestreUID = $semestre;
		
		if( !($etudiantUID=userRepo::UID($etudiant, $semestreUID)) ) return 'unknown_user';

		// on récupère la liste des UE
		$UEList = ueRepo::forStudent($etudiantUID, $semestreUID);

		foreach($UEList as $iter=>$UE) // pour chaque UE, on récupère la liste des modules
			$UEList[$iter]['modules'] = moduleRepo::forStudent($UE['id'], $semestreUID);
		
		return $UEList;
	}


	/******************************************/
	/*** retourne les modules d'un étudiant ***/
	/******************************************/
	public function getModulesEtudiant($etudiant, $semestre, $annee){
		// on vérifie que le semestre et l'étudiant existent
		if( !($semestreUID=semestreRepo::UID($semestre, $annee)) ) return 'unknown_semestre'; else $semestreUID = (int) $semestreUID;
		if( !($etudiantUID=userRepo::UID($etudiant)) ) return 'unknown_user';
		
		// on retourne les modules en supprimant les valeurs à indices numériques
		return moduleRepo::forStudent($etudiantUID, $semestreUID);
	}


	/**************************************/
	/*** retourne les UEs d'un étudiant ***/
	/**************************************/
	public function getUEsEtudiant($etudiant, $semestre, $annee){
		// on vérifie que le semestre et l'étudiant existent
		if( !($semestreUID=semestreRepo::UID($semestre, $annee)) ) return 'unknown_semestre'; else $semestreUID = (int) $semestreUID;
		if( !($etudiantUID=userRepo::UID($etudiant)) ) return 'unknown_user';


		// on retourne la liste d'UEs en supprimant les doublons à clés numériques
		return ueRepo::forStudent($etudiantUID, $semestreUID);
	}


	/**********************************************************/
	/*** retourne la liste exhaustive des MODULES de la BDD ***/
	/**********************************************************/
	public function getExhaustiveModuleList(){
		return moduleRepo::exhaustiveList();
	}


	/****************************************************/
	/*** retourne les modules d'un enseignant par UEs ***/
	/****************************************************/
	public function getModulesByUEByEnseignant($enseignant, $semestre_pair, $annee){
		// on vérifie que l'enseignant enseigne bien cette année
		if( !($enseignantUID=userRepo::UID($enseignant, null, $semestre_pair, $annee)) ) return 'unknown_teacher';

		// on récupère les semestres de cette année
		$semestreList = semestreRepo::forTeacher($enseignantUID, $semestre_pair, $annee);

		foreach($semestreList as $iter_s=>$a){
			$semestreList[$iter_s]['UElist'] = ueRepo::forTeacher($enseignantUID, $semestreList[$iter_s]['id']);

			foreach($semestreList[$iter_s]['UElist'] as $iter_u=>$b){
				$semestreList[$iter_s]['UElist'][$iter_u]['modules'] = moduleRepo::forTeacher($enseignantUID, $semestreList[$iter_s]['UElist'][$iter_u]['id'], $semestreList[$iter_s]['id']);
				

				foreach($semestreList[$iter_s]['UElist'][$iter_u]['modules'] as $iter_m=>$MOD){
					// on enregistre la liste des groupes inscrits
					$semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['groupes'] = groupRepo::inscritsMccModule($MOD['id_mcc_module']);
				
					foreach($semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['groupes'] as $iter_g=>$GROUPE){
						// on enregistre "true" si l'enseignant les enseigne, sinon "false"
						$semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['groupes'][$iter_g]['enseigne'] = userRepo::enseigne($enseignantUID, $MOD['id_mcc_module'], $GROUPE['id']);					
					}
					
				}


			}

		}

		return $semestreList;
	}


	/***************************************************/
	/*** retourne les modules des semestres en cours ***/
	/***************************************************/
	public function getModulesByUEByYear($semestre_pair, $annee){ // ***OPTIONNEL*** semestre_pair

		// on récupère les semestres de cette année
		$semestreList = semestreRepo::forYear($annee);

		foreach($semestreList as $iter_s=>$SEMESTRE){
			$semestreList[$iter_s]['UElist'] = ueRepo::forYear($SEMESTRE['id']);

			foreach($semestreList[$iter_s]['UElist'] as $iter_u=>$UE)
				$semestreList[$iter_s]['UElist'][$iter_u]['modules'] = moduleRepo::forYear($UE['id'], $SEMESTRE['id']);

		}

		return $semestreList;
	}


/*******************************************/
/*    _   _  ____ _______ ______  _____    */
/*   | \ | |/ __ \__   __|  ____|/ ____|   */
/*   |  \| | |  | | | |  | |__  | (___     */
/*   | . ` | |  | | | |  |  __|  \___ \    */
/*   | |\  | |__| | | |  | |____ ____) |   */
/*   |_| \_|\____/  |_|  |______|_____/    */
/*                                         */
/*******************************************/


	/*********************************************************/
	/* définie le caractère "publié" des notes d'un contrôle */
	/*********************************************************/
	public function publicationControle($controle, $publication){
		// on vérifie l'existence du contrôle en question
		if( !($controleObj=controleRepo::info($controle)) ) return 'unknown_controle';

		// on met à jour le caractère "publié" du contrôle
		return controleRepo::publication($controleObj['id'], $publication);
	}


	/**************************************/
	/*** retourne les notes par modules ***/
	/**************************************/
	public function getNotesByModules($etudiant, $semestre, $annee){
		// on vérifie que le semestre exist et que l'étudiant est inscrit à ce semestre
		if( !($semestreUID=semestreRepo::UID($semestre, $annee)) ) return 'unknown_semestre'; else $semestreUID = (int) $semestreUID;
		if( !($etudiantUID=userRepo::UID($etudiant, $semestreUID)) ) return 'unknown_user';


		$notelist = array(); // tableau qui contiendra tout les modules

		$modulelist = $this->getModulesEtudiant($etudiant, $semestre, $annee); // on récupère la liste des modules

		foreach($modulelist as $module){ // pour chaque module

			$notes = $this->getModuleNotes($etudiant, $module['nom'], $semestre, $annee); // on récupère les notes

			$current = array(); // on créé l'entrée qui sera dans le tableau de retour
			$current['module'] = array();
			$current['module']['nom'] = $module['nom']; // contenant le nom du module
			$current['module']['libelle'] = $module['libelle']; // contenant le nom du module
			$current['notes'] = $notes;          // et la liste de notes

			array_push($notelist, $current); // on l'ajoute au résultat
		}

		return $notelist;
	}


	/****************************************/
	/*** retourne les notes d'un étudiant ***/
	/****************************************/
	public function getNotesEtudiant($etudiant, $semestre){
		// on vérifie que le semestre exist et que l'étudiant est inscrit à ce semestre
		if( !semestreRepo::exists($semestre) ) return 'unknown_semestre';
		else $semestreUID = $semestre;

		if( !($etudiantUID=userRepo::UID($etudiant, $semestreUID)) ) return 'unknown_user';


		$UEList = ueRepo::forStudent($etudiantUID, $semestreUID);

		foreach($UEList as $iter_ue=>$a){
			$UEList[$iter_ue]['modules'] = moduleRepo::forStudent($UEList[$iter_ue]['id'], $semestreUID);

			foreach($UEList[$iter_ue]['modules'] as $iter_mod=>$b){
				$UEList[$iter_ue]['modules'][$iter_mod]['controles'] = controleRepo::forStudent($UEList[$iter_ue]['modules'][$iter_mod]['id'], $semestreUID);
			
				foreach($UEList[$iter_ue]['modules'][$iter_mod]['controles'] as $iter_ct=>$c)
					$UEList[$iter_ue]['modules'][$iter_mod]['controles'][$iter_ct]['notes'] = noteRepo::forStudent($etudiantUID, $UEList[$iter_ue]['modules'][$iter_mod]['controles'][$iter_ct]['id']);
			}

		} 

		return $UEList;
	}


	/*************************************************/
	/* retourne les informations du dossier étudiant */
	/*************************************************/
	public function getParcoursEtudiant($etudiant){
		// on vérifie l'existence de l'étudiant
		if( !($etudiantUID=userRepo::UID($etudiant)) ) return 'unknown_user';


		$parcours = semestreRepo::getParcours($etudiantUID);

		// contiendra les couples [id_formation, rang] pour les semestres capitalisables
		$listeSemestresCapitalisables = array();

		/* [1] Chaque semestre
		==========================*/
		foreach($parcours as $iter_s=>$semestre){
			// on récupère les id des UEs non pris en compte
			$inactiveUE = explode(',', $semestre['inactive']);
			// on supprime les entrées vides
			foreach($inactiveUE as $i=>$UE)
				if( strlen($UE) == 0 )
					unset($inactiveUE[$i]);

			// si des UEs non pris en compte, on ajoute le rang+formation à la liste
			if( count($inactiveUE) > 0 )
				if( !in_array( array($semestre['id_formation'], $semestre['rang']), $listeSemestresCapitalisables) )
					array_push($listeSemestresCapitalisables, array($semestre['id_formation'], $semestre['rang']));

			$parcours[$iter_s]['UEs'] = ueRepo::forStudent($etudiantUID, $semestre['id']);

			/* CALCUL DE MOYENNE DU SEMESTRE */
			$moyenneSemestre = 0; // contiendra la somme des valeurs*coefficients
			$totalSemestre   = 0; // contiendra la somme des coefficients

			// par défaut le semestre est compensable
			$semestreCompensable = true;
			// vrai si le semestre est obtenu par compensation des UE
			$semestreCompensation = false;


			/* [2] Chaque UE
			==========================*/
			foreach($parcours[$iter_s]['UEs'] as $iter_ue=>$UE){
				$parcours[$iter_s]['UEs'][$iter_ue]['modules'] = moduleRepo::forStudent($UE['id'], $semestre['id']);

				/* CALCUL DE MOYENNE DE L'UE */
				$moyenneUE = 0; // contiendra la somme des valeurs*coefficients
				$totalUE   = 0; // contiendra la somme des coefficients

				/* [3] Chaque module
				==========================*/
				foreach($parcours[$iter_s]['UEs'][$iter_ue]['modules'] as $iter_mod=>$MOD){
					$parcours[$iter_s]['UEs'][$iter_ue]['modules'][$iter_mod]['controles'] = controleRepo::forStudent($MOD['id'], $semestre['id']);
					
					$parcours[$iter_s]['UEs'][$iter_ue]['modules'][$iter_mod]['moyenne'] = noteRepo::moyenneModule($etudiantUID, $MOD['id'], $semestre['id']);


					// on complète la moyenne de l'UE si le module a une moyenne
					$tmpModule = $parcours[$iter_s]['UEs'][$iter_ue]['modules'][$iter_mod];

					if( !is_bool($tmpModule['moyenne']) ){
						$moyenneUE += $tmpModule['moyenne']['moyenne']/$tmpModule['moyenne']['base'] * $tmpModule['coefficient'];
						$totalUE   += $tmpModule['coefficient'];
					}

					/* [4] Chaque contrôle
					==========================*/
					foreach($parcours[$iter_s]['UEs'][$iter_ue]['modules'][$iter_mod]['controles'] as $iter_ct=>$CONTROLE)
						$parcours[$iter_s]['UEs'][$iter_ue]['modules'][$iter_mod]['controles'][$iter_ct]['notes'] = noteRepo::forStudent($etudiantUID, $CONTROLE['id']);
					
					
				}

				/* ENREGISTREMENT DE LA MOYENNE DE L'UE */
				if( $totalUE == 0 ) // si la somme vaut 0, on retourne FALSE
					$parcours[$iter_s]['UEs'][$iter_ue]['moyenne'] = false;
				else
					$parcours[$iter_s]['UEs'][$iter_ue]['moyenne'] = array('moyenne' => 20*$moyenneUE/$totalUE, 'base' => 20 );


				// on complète la moyenne du semestre
				// SI l'UE a une moyenne
				$tmpUE = $parcours[$iter_s]['UEs'][$iter_ue];

				if( !is_bool($tmpUE['moyenne']) ){
					$moyenneSemestre += $tmpUE['moyenne']['moyenne']/$tmpUE['moyenne']['base'] * $tmpUE['coefficient'];
					$totalSemestre   += $tmpUE['coefficient'];

					// le semestre est non compensable si la moyenne d'au moins un UE < 8
					if( 20*$tmpUE['moyenne']['moyenne']/$tmpUE['moyenne']['base'] < 8 )
						$semestreCompensable = false;

					// semestreCompensé est VRAI si au moins un semestre est entre 8 et 10
					if( 20*$tmpUE['moyenne']['moyenne']/$tmpUE['moyenne']['base'] >= 8 && 20*$tmpUE['moyenne']['moyenne']/$tmpUE['moyenne']['base'] < 10 )
						$semestreCompensation = true;
				}

			} 


			/* ENREGISTREMENT DE LA MOYENNE DU SEMESTRE */
			// on enregistre les valeurs du calcul pour pouvoir calculer avec compensation
			$parcours[$iter_s]['calculMoyenne'] = array( 'sum' => $moyenneSemestre, 'count' => $totalSemestre );

			if( $totalSemestre == 0 ) // si la somme vaut 0, on retourne FALSE
				$parcours[$iter_s]['moyenne'] = false;
			else{
				// on enregistre la moyenne
				$parcours[$iter_s]['moyenne'] = array('moyenne' => 20*$moyenneSemestre/$totalSemestre, 'base' => 20 );
			}

			$parcours[$iter_s]['compensable'] = $semestreCompensable;

			// si le semestre est obtenu et utilise la compensation => on le définit
			if( $semestreCompensable && $semestreCompensation && $parcours[$iter_s]['moyenne']['moyenne'] >= 10 )
				$parcours[$iter_s]['compensation'] = true;
			else
				$parcours[$iter_s]['compensation'] = false;

			// on met la liste des id d'ue inactifs sous forme de tableau
			$parcours[$iter_s]['inactive'] = $inactiveUE;
		}


		/* LISTE DES UES CAPITALISÉES PAR SEMESTRES REGROUPÉS (FORMATION+RANG) */
		// On ajoute toutes les UE capitalisées
		foreach($listeSemestresCapitalisables as $i=>$formationRang){

			// pour cette formation+rang, on récupère toutes les UEs
			$listeUEs = array();
			$UEUIDS = array();
			$listeSemestresIndexes = array();

			foreach($parcours as $iter_s=>$semestre){

				// si fait partie de la formation+rang courante
				if( $formationRang == array( $semestre['id_formation'], $semestre['rang'] ) ){

					// on ajoute l'index du semestre à la liste
					array_push($listeSemestresIndexes, $iter_s);

					// on ajoute chaque UE de ce semestre s'il est actif
					foreach($semestre['UEs'] as $UE)
						if( !in_array($UE['id'], $semestre['inactive']) ){
							if( array_search($UE['id'], $UEUIDS) === false ){
								// pour le premier UE (capitalisé) on s'assure de lui attribuer la capitalisation
								DataBase::getInstance()->capitaliserUE($UE['id'], $semestre['id'], $etudiantUID);
								array_push( $listeUEs, $UE );
								array_push( $UEUIDS, $UE['id'] );
							}//else // si UE existe déjà pour formation+rang, on créé la capitalisation du semestre (on le désactive)
						}
				}

			}

			// variables utiles pour la moyenne
			$moyenneSemestre = 0; $totalSemestre = 0;
			$semestreCompensable = true; $semestreCompensation = true;

			// pour chaque UE capitalisée
			foreach($listeUEs as $iter_ue=>$UE){
				// si l'UE a une moyenne
				if( !is_bool($UE['moyenne']) ){
					$moyenneSemestre += $UE['moyenne']['moyenne']/$UE['moyenne']['base'] * $UE['coefficient'];
					$totalSemestre   += $UE['coefficient'];

					// le semestre est non compensable si la moyenne d'au moins un UE < 8
					if( 20*$UE['moyenne']['moyenne']/$UE['moyenne']['base'] < 8 )
						$semestreCompensable = false;

					// semestreCompensé est VRAI si au moins un semestre est entre 8 et 10
					if( 20*$UE['moyenne']['moyenne']/$UE['moyenne']['base'] >= 8 && 20*$UE['moyenne']['moyenne']/$UE['moyenne']['base'] < 10 )
						$semestreCompensation = true;
				}
			}


			// attribution des moyennes aux semestres concernés
			foreach($listeSemestresIndexes as $index){
				if( $totalSemestre > 0 )
					$parcours[$index]['moyenne'] = array( 'moyenne' => 20*$moyenneSemestre/$totalSemestre, 'base' => 20 );
				else
					$parcours[$index]['moyenne'] = array( 'moyenne' => 0, 'base' => 20 );

				// on met à jour le semestre compensable, et compensation
				$parcours[$index]['compensable']  = $semestreCompensable;
				$parcours[$index]['compensation'] = $semestreCompensation;
			}

		}

		return $parcours;
	}


	/*******************************************/
	/*** retourne les notes d'un enseignant  ***/
	/*******************************************/
	public function getControlesEnseignant($enseignant, $semestre_pair, $annee){
		// on vérifie que le semestre existe et que l'enseignant y enseigne
		if( !($enseignantUID=userRepo::UID($enseignant, null, $semestre_pair, $annee)) ) return 'unknown_teacher';

		// on récupère les semestres de cette année
		$semestreList = semestreRepo::forTeacher($enseignantUID, $semestre_pair, $annee);

		foreach($semestreList as $iter_s=>$a){

			$semestreList[$iter_s]['UElist'] = ueRepo::forTeacher($enseignantUID, $semestreList[$iter_s]['id']);

			foreach($semestreList[$iter_s]['UElist'] as $iter_u=>$b){
				$semestreList[$iter_s]['UElist'][$iter_u]['modules'] = moduleRepo::forTeacher($enseignantUID, $semestreList[$iter_s]['UElist'][$iter_u]['id'], $semestreList[$iter_s]['id']);

				foreach($semestreList[$iter_s]['UElist'][$iter_u]['modules'] as $iter_m=>$c){
					$semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['controles'] = controleRepo::forTeacher($enseignantUID, $semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['id'], $semestreList[$iter_s]['id']);
				
					foreach($semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['controles'] as $iter_ct=>$c){
						$semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['controles'][$iter_ct]['grouplist'] = noteRepo::forControle($semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['controles'][$iter_ct]['id']);

						$semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['controles'][$iter_ct]['moyenne'] = noteRepo::moyenneForControle($semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['controles'][$iter_ct]['id']);

					}

				}

			}

		}

		return $semestreList;
	}


	/***************************************/
	/*** retourne les notes d'une année  ***/
	/***************************************/
	public function getControlesForYear($annee){
		// on récupère les semestres de cette année
		$semestreList = semestreRepo::forYear($annee);

		foreach($semestreList as $iter_s=>$a){
			$semestreList[$iter_s]['UElist'] = ueRepo::forYear($semestreList[$iter_s]['id']);

			foreach($semestreList[$iter_s]['UElist'] as $iter_u=>$b){
				$semestreList[$iter_s]['UElist'][$iter_u]['modules'] = moduleRepo::forYear($semestreList[$iter_s]['UElist'][$iter_u]['id'], $semestreList[$iter_s]['id']);

				foreach($semestreList[$iter_s]['UElist'][$iter_u]['modules'] as $iter_m=>$c){
					$semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['controles'] = controleRepo::forYear($semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['id'], $semestreList[$iter_s]['id']);

					foreach($semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['controles'] as $iter_ct=>$c){
						$semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['controles'][$iter_ct]['grouplist'] = noteRepo::forControle($semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['controles'][$iter_ct]['id']);

						$semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['controles'][$iter_ct]['moyenne'] = noteRepo::moyenneForControle($semestreList[$iter_s]['UElist'][$iter_u]['modules'][$iter_m]['controles'][$iter_ct]['id']);

					}

				}

			}

		}

		return $semestreList;
	}


	/***********************************************************/
	/*** retourne les notes pour un contrôle d'un enseignant ***/
	/***********************************************************/
	public function getNotesForControleEnseignant($enseignant, $annee, $controle, $groupe=null){ // [OPTIONNEL] $groupe

		// on vérifie que le semestre existe et que l'enseignant y enseigne
		if( !($enseignantUID=userRepo::UID($enseignant)) )  return 'unknown_teacher';

		// on récupère les informations du contrôle
		if( !($controlObj=controleRepo::info($controle, $enseignant, $groupe)) ) return 'unknown_controle';

		// on ajoute la moyenne au contrôle
		$controlObj['moyenne'] = noteRepo::moyenneForControle($controlObj['id']);

		/* [1] si le groupe est donné
		=======================================*/
		if( $groupe != null ){
			if( !($groupeUID=groupRepo::info($groupe)['id']) ) return 'unknown_group'; else $groupeUID = (int) $groupeUID; // on récupère l'UID du groupe

			$controlObj['moyenneGroupe'] = noteRepo::forGroupe($controle, $groupeUID)['moyenne'];

			$controlObj['userlist'] = groupRepo::membres($groupeUID, $controlObj['id_semestre']); // on récupère la liste des étudiants de ce groupe

			foreach($controlObj['userlist'] as $iter=>$note)
				if( $resultNote = noteRepo::forStudent($controlObj['userlist'][$iter]['identifiant'], $controle) ) // si l'étudiant a une note pour ce controle
					$controlObj['userlist'][$iter]['note'] = $resultNote[0]['valeur'];
				else
					$controlObj['userlist'][$iter]['note'] = null;

		/* [2] si on veut par groupe
		=======================================*/
		}else{
			$controlObj['grouplist'] = groupRepo::forControle($controle, $enseignant);

			foreach($controlObj['grouplist'] as $iter=>$grpe)
				if( $controleNotes = noteRepo::forGroupe($controle, $grpe['id_groupe']) ) // si le groupe a des notes, on les ajoutes
					$controlObj['grouplist'][$iter] = array_merge($controlObj['grouplist'][$iter], $controleNotes);
			
		}

		return $controlObj;
	}


	/*******************************************/
	/*** retourne les notes pour un contrôle ***/
	/*******************************************/
	public function getNotesForControle($annee, $controle, $groupe=null){ // [OPTIONNEL] $groupe

		// on récupère les informations du contrôle
		if( !($controlObj=controleRepo::info($controle)) ) return 'unknown_controle';

		// on ajoute la moyenne au contrôle
		$controlObj['moyenne'] = noteRepo::moyenneForControle($controlObj['id']);

		/* [1] si le groupe est donné
		=======================================*/
		if( $groupe != null ){
			if( !($groupeUID=groupRepo::info($groupe)['id']) ) return 'unknown_group'; else $groupeUID = (int) $groupeUID; // on récupère l'UID du groupe

			$controlObj['moyenneGroupe'] = noteRepo::forGroupe($controle, $groupeUID)['moyenne'];

			$controlObj['userlist'] = groupRepo::membres($groupeUID, $controlObj['id_semestre']); // on récupère la liste des étudiants de ce groupe

			foreach($controlObj['userlist'] as $iter=>$note)
				if( $resultNote = noteRepo::forStudent($controlObj['userlist'][$iter]['identifiant'], $controle) ) // si l'étudiant a une note pour ce controle
					$controlObj['userlist'][$iter]['note'] = $resultNote[0]['valeur'];
				else
					$controlObj['userlist'][$iter]['note'] = null;

		/* [2] si on veut par groupe
		=======================================*/
		}else{
			$controlObj['grouplist'] = groupRepo::forControle($controle);

			foreach($controlObj['grouplist'] as $iter=>$grpe)
				if( $controleNotes = noteRepo::forGroupe($controle, $grpe['id_groupe']) ) // si le groupe a des notes, on les ajoutes
					$controlObj['grouplist'][$iter] = array_merge($controlObj['grouplist'][$iter], $controleNotes);
			
			// var_dump(  $controlObj );
			debug();
		}

		return $controlObj;
	}


	/******************************************/
	/*** saisie note étudiant à un contrôle ***/
	/******************************************/
	public function saisieNote($etudiant, $controle, $note){
		// on vérifie l'existence de l'étudiant et du contrôle, ainsi que la cohérence de la note (pas supérieure à la base)
		if( !($etudiantUID=userRepo::UID($etudiant)) ) return 'unknown_user';
		if( !($controleInfo=controleRepo::info($controle)) ) return 'unknown_controle';
		if( $note > $controleInfo['base'] ) return 'unknown_note';

		// saisie de la note
		$rep = noteRepo::creer($etudiantUID, $controleInfo['id'], $controleInfo['id_semestre'], $note);
		
		// var_dump( $rep );

		if( $rep )
			return 'success';
		else
			return 'error';

	}


	/******************************/
	/*** saisie notes multiples ***/
	/******************************/
	public function saisieNoteMultiple($controle, $notes){
		if( !($controleInfo=controleRepo::info($controle)) ) return 'unknown_controle';

		foreach($notes as $iter=>$NOTE){

			$NOTE->valeur = floatval($NOTE->valeur);

			// on vérifie l'existence de l'étudiant et du contrôle, ainsi que la cohérence de la note (pas supérieure à la base)
			if( !(userRepo::UID($NOTE->etudiant)) ) return 'unknown_user';

			// si la note > base du contrôle, on supprime la note
			if( $NOTE->valeur > $controleInfo['base'] )
				unset( $notes[$iter] );
		}

		// saisie multiple des notes
		$rep = noteRepo::creerMultiple($controleInfo['id'], $controleInfo['id_semestre'], $notes);

		if( $rep )
			return 'success';
		else
			return 'error';

	}

}

?>