<?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 )
			DataBase::$instance = new DataBase("localhost", "sid2", "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;
	}

	
/*********************************************************************************/
/*                               __  __  ____ ____                               */
/*                              |  \/  |/ ___/ ___|                              */
/*                              | |\/| | |  | |                                  */
/*                              | |  | | |__| |___                               */
/*                              |_|  |_|\____\____|                              */
/*                                                                               */
/*********************************************************************************/
	
	/* intègre un MCC à la BDD
	*
	* @semestre<int>			l'UID du semestre concerné
	* @mcc<Array>				contient toutes les données du MCC
	*
	*/
	public static 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']);
				// echo '&nbsp&nbsp'.$module['nom'].'<br>';

				foreach($module['controles'] as $controle){

					$controle_uid = controleRepo::forMCC($mcc_module, $controle['nom'], $controle['libelle'], $controle['coefficient']);
					// var_dump( $controle_uid );
					// echo '&nbsp&nbsp&nbsp&nbsp'.$controle['nom'].'<br>';

				}


			}


		}

	}


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


	/*********************************************/
	/*** 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 à ajouter au groupe
	*
	* @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 $semestre;
		else
			return 'error';
	}


	/* 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 static function listeUtilisateursRole(){
		return userRepo::getRoleUsers();
	}


	/* 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 static 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;
	}

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


	/****************************************/
	/*** 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, $formation, $semestre, $annee){
		// on vérifie que le groupe et le semestre existent
		if( !($semestreUID=semestreRepo::UID($formation, $semestre, $annee)) ) return 'unknown_semestre'; else $semestreUID = (int) $semestreUID;
		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($formation, $semestre, $annee){
		// on vérifie que le semestre existe
		if( !($semestreUID=semestreRepo::UID($formation, $semestre, $annee)) ) return 'unknown_semestre'; else $semestreUID = (int) $semestreUID;


		// on cherche tout les groupes du même semestre de la même année
		$getGroupesUID = DataBase::getPDO()->prepare("SELECT DISTINCT g.id_groupe as id, g.nom, s.rang, s.nom as semestre  ".
			"FROM groupe as g, semestre as s, appartenance as app ".
			"WHERE g.id_groupe   = app.id_groupe ".
			"AND   s.id_semestre = app.id_semestre ".
			
			"AND   s.id_semestre = :semestreUID ".
			"ORDER BY g.nom");
		$getGroupesUID->execute(array(
			':semestreUID'  => $semestreUID
		));

		$grouplist = $getGroupesUID->fetchAll(); // 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 cherche un semestre avec ce rang et cette année (qui est unique) ***/
		$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 récupère la liste des groupes
		$grouplist = DataBase::delNumeric( 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 un étudiant d'un groupe à un autre *****/
	/******************************************************/
	public function deplacerEtudiant($etudiant, $groupe, $semestre){

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

		if( groupRepo::ajouterMembre($etudiant, $destGroupeUID, $semestreInfo['id']) )
			return 'success';
		else
			return 'error';

	}


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


	/**************************************************/
	/*** retourne les modules d'un étudiant par UEs ***/
	/**************************************************/
	public function getModulesByUEByEtudiant($etudiant, $formation, $semestre, $annee){
		// on vérifie que le semestre et l'utilisateur existent
		if( !($semestreUID=semestreRepo::UID($formation, $semestre, $annee)) ) return 'unknown_semestre'; else $semestreUID = (int) $semestreUID;
		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']);

		}

		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=>$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']);
				
			}

		}

		return $semestreList;
	}


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


	/**************************************/
	/*** 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, $formation, $semestre, $annee){
		// on vérifie que le semestre exist et que l'étudiant est inscrit à ce semestre
		if( !($semestreUID=semestreRepo::UID($formation, $semestre, $annee)) ) return 'unknown_semestre'; else $semestreUID = (int) $semestreUID;
		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 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';
		debug();
		// 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::forTeacher($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  ***/
	/********************************************/
	public function getNotesEnseignant($enseignant, $semestre_pair, $annee, $controle, $groupe=null){ // [OPTIONNEL] $groupe

		// on récupère les informations du contrôle
		if( ! ($controlObj=controleRepo::info($controle, $enseignant)) ) 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::UID($groupe)) ) return 'unknown_group'; else $groupeUID = (int) $groupeUID; // on récupère l'UID du groupe

			$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';

	}

}

?>