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

/**************************************************************/
/*   _   _ ____  _____ ____         ____  _____ ____   ___    */
/*  | | | / ___|| ____|  _ \       |  _ \| ____|  _ \ / _ \   */
/*  | | | \___ \|  _| | |_) |      | |_) |  _| | |_) | | | |  */
/*  | |_| |___) | |___|  _ <       |  _ <| |___|  __/| |_| |  */
/*   \___/|____/|_____|_| \_\      |_| \_\_____|_|    \___/   */
/*                                                            */
/**************************************************************/

class userRepo{
	/* VERIFIE L'EXISTENCE D'UN UTILISATEUR DANS LA BDD
	*
	* @identifiant<String>		l'identifiant de l'utilisateur recherché
	* 
	* @semestre<int>			***OPTIONNEL*** l'UID du semestre auquel on veut vérifier que l'étudiant est inscrit
	* 
	* @semestre_pair<Boolean>	***OPTIONNEL*** détermine si le semestre est pair ou non
	* @annee<int>				***OPTIONNEL*** l'année auquelle on veut vérifier si l'enseignant enseigne
	* 
	* @return  UID<String>		si l'utilisateur est dans la BDD, retourne son UID
	* @return  FALSE<Boolean>	FAUX si l'utilisateur n'est pas présent dans la BDD
	* 
	*/
	public static function UID($identifiant, $semestre=null, $semestre_pair=null, $annee=null){

		if( $semestre == null && $semestre_pair == null && $annee == null ){ // on cherche un utilisateur avec cet identifiant
		
			/* [1] Cas où on cherche juste si l'utilisateur existe
			=============================================================*/
			$getUtilisateurUID = DataBase::getPDO()->prepare("SELECT identifiant as id FROM utilisateur WHERE identifiant = :identifiant");
			$getUtilisateurUID->execute(array( ':identifiant' => $identifiant ));
		
		}elseif( $semestre != null ){
			
			/* [2] Cas où on cherche si un étudiant est inscrit à un semestre
			==============================================================*/
			$getUtilisateurUID = DataBase::getPDO()->prepare("SELECT u.identifiant as id
				FROM utilisateur as u, appartenance as app
				WHERE u.identifiant = app.id_etudiant
				AND   u.identifiant = :identifiant
				AND   app.id_semestre = :semestre");
			$getUtilisateurUID->execute(array( ':identifiant' => $identifiant, ':semestre' => $semestre ));

		}elseif( $annee != null ){

			$semestrePair0 = '0'; $semestrePair1 = '1';
			if( is_bool($semestre_pair) ){ $semestrePair0 = ($semestre_pair)?'0':'1'; $semestrePair1 = ($semestre_pair)?'0':'1'; }


			/* [2] Cas où on cherche si un enseignant enseigne l'année donnée
			==============================================================*/
			$getUtilisateurUID = DataBase::getPDO()->prepare("SELECT DISTINCT ens.id_enseignant as id
				FROM enseignement as ens, semestre as s, mcc_module as mcc_m, mcc_ue
				WHERE ens.id_mcc_module = mcc_m.id_mcc_module
				AND   mcc_m.id_mcc_ue = mcc_ue.id_mcc_ue
				AND   mcc_ue.id_semestre = s.id_semestre

				AND   ens.id_enseignant = :identifiant
				AND   (s.rang % 2 = :semestre_pair0 OR s.rang % 2 = :semestre_pair1)
				AND   s.annee = :annee");
			$getUtilisateurUID->execute(array( ':identifiant' => $identifiant, ':semestre_pair0' => $semestrePair0, ':semestre_pair1' => $semestrePair1, ':annee' => $annee ));

		}else // si les paramètres sont pas bons
			return false;

		// on retourne le résultat : FAUX si aucun résultat, sinon la valeur de l'UID de l'utilisateur
		return $getUtilisateurUID->fetch()['id'];
	}


	/* RENVOIE LES INFORMATIONS D'UN UTILISATEUR D'UID DONNÉ
	*
	* @utilisateurUID<int>				l'UID de l'utilisateur duquel on veut les infos
	*
	* @return utilisateur<Array>		tableau associatif contenant tout les champs de la BDD pour cet utilisateur
	*
	*/
	public static function info($utilisateurUID){
		// on considère que le semestre existe
		$getUtilisateurInfo = DataBase::getPDO()->prepare("SELECT identifiant, prenom, nom, sexe, mail, droits FROM utilisateur WHERE identifiant = :utilisateurUID");
		$getUtilisateurInfo->execute(array( ':utilisateurUID' => $utilisateurUID ));

		// on retourne le résultat en supprimant les doublons à indices numériques
		return DataBase::delNumeric( $getUtilisateurInfo->fetch(), true );
	}


	/* retourne si un enseignant enseigne un mcc_module à un groupe
	*
	* @enseignant<String>					l'UID de l'enseignant en question
	* @mcc_module<int>						l'UID du mcc_module en question
	* @groupe<int>							l'UID du groupe en question
	*
	*
	* @return enseigne<Boolean>				retourne TRUE si l'enseignant enseigne le mcc_module pour ce groupe, FALSE sinon
	*
	*/
	public static function enseigne($enseignant, $mcc_module, $groupe){
		$getEnseignementsListe = DataBase::getPDO()->prepare("SELECT id_enseignement as id
			FROM enseignement
			WHERE id_enseignant = :enseignant
			AND   id_mcc_module = :mcc_module
			AND   id_groupe = :groupe");
		$getEnseignementsListe->execute(array( ':enseignant' => $enseignant, ':mcc_module' => $mcc_module, ':groupe' => $groupe ));

		return $getEnseignementsListe->fetch() !== false;
	}


	/* retourne la liste des enseignants de la BDD
	*
	* @return enseignants<Array>		retourne la liste des enseignants
	* @return FALSE<Boolean>			retourne FAUX si aucun résultat
	*
	*/
	public static function getRoleUsers(){
		$getListeUtilisateurs = DataBase::getPDO()->query("SELECT DISTINCT identifiant as id, nom, prenom, droits as role
			FROM utilisateur
			WHERE droits <> 'student'
			ORDER BY identifiant ASC");

		// si aucun résultat, on retourne false
		if( !($userlist=$getListeUtilisateurs->fetchAll()) )
			return false;

		$userlist = DataBase::delNumeric( $userlist );

		// sinon on met les rôles sous forme de tableau
		foreach($userlist as $iter=>$user)
			$userlist[$iter]['role'] = explode(',', $user['role']);

		return $userlist;
	}


	/* 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 static function setAdmin($utilisateur, $admin){
		/* [1] On récupère les droits actuels de l'utilisateur
		=========================================================*/
		if( !($utilisateurInfo=userRepo::info($utilisateur)) ) return false;

		$droitsArray = explode(',', $utilisateurInfo['droits'] );
		// on supprime les entrées vides
		foreach($droitsArray as $i=>$droit)
			if( strlen($droit) == 0 )
				unset($droitsArray[$i]);

		/* [2] On modifie les droits en fonction des paramètres
		=========================================================*/
		if( $admin && !in_array('admin', $droitsArray) ) // si on doit ajouter le droit et qu'il n'y est pas encore
			array_push($droitsArray, 'admin');           // => on ajoute 'admin'

		if( !$admin && in_array('admin', $droitsArray) ) // si on doit enlever le droit et qu'il y est
			array_splice($droitsArray, array_search('admin', $droitsArray), 1 ); // => on enleve 'admin'

		$droitsString = implode(',', $droitsArray);


		/* [3] On modifie les droits dans la BDD
		=========================================================*/
		$modifierAdmin = DataBase::getPDO()->prepare("UPDATE utilisateur SET droits = :droits WHERE identifiant = :identifiant");
		$modifierAdmin->execute(array( ':droits' => $droitsString, ':identifiant' => $utilisateur ));


		/* [4] On vérifie que les changements on bien pris effet
		=========================================================*/
		if( !($utilisateurInfoVerif=userRepo::info($utilisateur)) ) return false;
		
		return $utilisateurInfoVerif['droits'] == $droitsString; // si les droits de la BDD sont les mêmes que ceux calculés, c'est que c'est ok
	}


	/* 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 static function setMaster($utilisateur, $master){
		/* [1] On récupère les droits actuels de l'utilisateur
		=========================================================*/
		if( !($utilisateurInfo=userRepo::info($utilisateur)) ) return false;

		$droitsArray = explode(',', $utilisateurInfo['droits'] );
		// on supprime les entrées vides
		foreach($droitsArray as $i=>$droit)
			if( strlen($droit) == 0 )
				unset($droitsArray[$i]);

		/* [2] On modifie les droits en fonction des paramètres
		=========================================================*/
		if( $master && !in_array('master', $droitsArray) ) // si on doit ajouter le droit et qu'il n'y est pas encore
			array_push($droitsArray, 'master');           // => on ajoute 'master'

		if( !$master && in_array('master', $droitsArray) ) // si on doit enlever le droit et qu'il y est
			array_splice($droitsArray, array_search('master', $droitsArray), 1 ); // => on enleve 'master'

		$droitsString = implode(',', $droitsArray);


		/* [3] On modifie les droits dans la BDD
		=========================================================*/
		$modifierAdmin = DataBase::getPDO()->prepare("UPDATE utilisateur SET droits = :droits WHERE identifiant = :identifiant");
		$modifierAdmin->execute(array( ':droits' => $droitsString, ':identifiant' => $utilisateur ));


		/* [4] On vérifie que les changements on bien pris effet
		=========================================================*/
		if( !($utilisateurInfoVerif=userRepo::info($utilisateur)) ) return false;
		
		return $utilisateurInfoVerif['droits'] == $droitsString; // si les droits de la BDD sont les mêmes que ceux calculés, c'est que c'est ok
	}


	/* modifie le caractère "teacher" d'un utilisateur
	*
	* @utilisateur<String>				l'UID de l'utilisateur en question
	* @teacher<Boolean>					VRAI si teacher, FAUX sinon
	*
	*
	* @return updated<Boolean>			VRAI si la modification a été faite
	*
	*/
	public static function setTeacher($utilisateur){
		/* [1] On récupère les droits actuels de l'utilisateur
		=========================================================*/
		if( !($utilisateurInfo=userRepo::info($utilisateur)) ) return false;

		$droitsArray = explode(',', $utilisateurInfo['droits'] );
		// on supprime les entrées vides
		foreach($droitsArray as $i=>$droit)
			if( strlen($droit) == 0 )
				unset($droitsArray[$i]);


		// on récupère le nombre d'enseignements de l'utilisateur
		$getNumEnseignements = DataBase::getPDO()->prepare("SELECT count(distinct id_enseignement) as nb_ens
			FROM enseignement
			WHERE id_enseignant = :utilisateurUID");
		$getNumEnseignements->execute(array( ':utilisateurUID' => $utilisateur ));

		// VRAI si enseigne au moins un module
		$teacher = $getNumEnseignements->fetch()['nb_ens'] > 0;

		/* [2] On modifie les droits en fonction des paramètres
		=========================================================*/
		if( $teacher && !in_array('teacher', $droitsArray) ) // si on doit ajouter le droit et qu'il n'y est pas encore
			array_push($droitsArray, 'teacher');           // => on ajoute 'teacher'

		if( !$teacher && in_array('teacher', $droitsArray) ) // si on doit enlever le droit et qu'il y est
			array_splice($droitsArray, array_search('teacher', $droitsArray), 1 ); // => on enleve 'teacher'

		$droitsString = implode(',', $droitsArray);


		/* [3] On modifie les droits dans la BDD
		=========================================================*/
		$modifierTeacger = DataBase::getPDO()->prepare("UPDATE utilisateur SET droits = :droits WHERE identifiant = :identifiant");
		$modifierTeacger->execute(array( ':droits' => $droitsString, ':identifiant' => $utilisateur ));


		/* [4] On vérifie que les changements on bien pris effet
		=========================================================*/
		if( !($utilisateurInfoVerif=userRepo::info($utilisateur)) ) return false;
		
		return $utilisateurInfoVerif['droits'] == $droitsString; // si les droits de la BDD sont les mêmes que ceux calculés, c'est que c'est ok
	}


	/* ajoute un module qu'un utilisateur peut corriger (pour un groupe)
	*
	* @utilisateur<String>				l'UID de l'utilisateur en question
	* @mccmodule<int>					l'UID du mcc_module à ajouter
	* @groupe<int>						l'UID du groupe en question
	*
	*
	* @return added<Boolean>			VRAI si module ajouté, sinon FALSE
	*
	*/
	public static function addModule($utilisateur, $mccmodule, $groupe){
		/* [1] On vérifie s'il n'enseigne pas déjà pour ce module
		==============================================================*/
		$enseignementExiste = DataBase::getPDO()->prepare("SELECT id_enseignement as id
			FROM enseignement
			WHERE id_enseignant = :utilisateur
			AND   id_mcc_module = :mccmodule
			AND   id_groupe     = :groupe");
		$enseignementExiste->execute(array( ':utilisateur' => $utilisateur, ':mccmodule' => $mccmodule, ':groupe' => $groupe ));


		/* [2] Si l'enseignement existe, on retourne TRUE
		==============================================================*/
		if( $enseignementExiste->fetch() ) return true;
			

		/* [3] Si l'enseignement n'existe, on le créé
		==============================================================*/
		$creerEnseignement = DataBase::getPDO()->prepare("INSERT INTO enseignement(id_enseignement, id_enseignant, id_mcc_module, id_groupe, correcteur)
			VALUES(DEFAULT, :utilisateur, :mccmodule, :groupe, 1)");
		$creerEnseignement->execute(array( ':utilisateur' => $utilisateur, ':mccmodule' => $mccmodule, ':groupe' => $groupe ));
		

		/* [4] On vérifie que l'enseignement a été créé
		==============================================================*/
		$enseignementExiste = DataBase::getPDO()->prepare("SELECT id_enseignement as id
			FROM enseignement
			WHERE id_enseignant = :utilisateur
			AND   id_mcc_module = :mccmodule
			AND   id_groupe = :groupe");
		$enseignementExiste->execute(array( ':utilisateur' => $utilisateur, ':mccmodule' => $mccmodule, ':groupe' => $groupe ));

	
		return is_array($enseignementExiste->fetch());
	}


	/* 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>						l'UID du groupe en question
	*
	*
	* @return removed<Boolean>			VRAI si module supprimé, sinon FALSE
	*
	*/
	public static function delModule($utilisateur, $mccmodule, $groupe){
		/* [1] On vérifie s'il n'enseigne pas déjà pour ce module
		==============================================================*/
		$enseignementExiste = DataBase::getPDO()->prepare("SELECT id_enseignement as id
			FROM enseignement
			WHERE id_enseignant = :utilisateur
			AND   id_mcc_module = :mccmodule
			AND   id_groupe = :groupe");
		$enseignementExiste->execute(array( ':utilisateur' => $utilisateur, ':mccmodule' => $mccmodule, ':groupe' => $groupe ));


		/* [2] Si l'enseignement n'existe pas, on returne "TRUE
		==============================================================*/
		if( !($enseignementUID=$enseignementExiste->fetch()['id']) ) return true;


		/* [3] Si l'enseignement existe, on le supprime
		==============================================================*/
		$supprimerEnseignement = DataBase::getPDO()->prepare("DELETE FROM enseignement WHERE id_enseignement = :enseignementUID");
		$supprimerEnseignement->execute(array( ':enseignementUID' => $enseignementUID ));

		/* [4] On vérifie que l'enseignement a été supprimé
		==============================================================*/
		$enseignementExiste = DataBase::getPDO()->prepare("SELECT id_enseignement as id
			FROM enseignement
			WHERE id_enseignant = :utilisateur
			AND   id_mcc_module = :mccmodule
			AND   id_groupe = :groupe");
		$enseignementExiste->execute(array( ':utilisateur' => $utilisateur, ':mccmodule' => $mccmodule, ':groupe' => $groupe ));

	
		return !is_array($enseignementExiste->fetch());
	}


	/* CREE UN NOUVEL UTILISATEUR DANS LA BASE DE DONNES
	*
	* @identifiant<String>			l'identifiant (unique) de l'utilisateur à créer
	* @prenom<String>				le prénom du nouvel utilisateur
	* @nom<String>					le nom du nouvel utilisateur
	* @mail<String>					le mail du nouvel utilisateur
	* @mdp<String>					le mot de passe du nouvel utilisateur
	* @droits<Array>				les droits à donner au nouvel utilisateur
	*
	* @return UID<String>			l'UID du nouvel utilisateur s'il a bien été créé
	* @return created<Boolean>		VRAI si l'utilisateur n'existait pas déjà* et qu'il a bien été créé
	*								(*) Si aucun autre n'avait le même @identifiant
	* 
	*/
	public static function creer($identifiant, $prenom, $nom, $sexe, $mail, $mdp, $droits){
		/* [1] On normalise les données
		=================================================================================================*/
		foreach($droits as $droit)
			if( !is_int( array_search($droit, getPermissions()) ) ) // si le droit n'est pas dans la liste des droits existants
				return false; // on retourne une erreur comme quoi le droit est inexistant


		$identifiant = strtolower($identifiant);       // on met l'identifiant en minuscule
		$prenom      = ucwords( strtolower($prenom) ); // majuscule à chaque mot sinon minuscule
		$nom         = strtoupper($nom);               // nom en majuscules
		$sexe        = boolval($sexe);                 // VRAI pour homme / FAUX pour femme
		$mail        = strtolower($mail);              // email en minuscules
		$mdp         = secure_sha1($mdp);              // on hash le password (SHA1)
		$droits      = implode(',', $droits);          // on met le droit sous forme de chaine

		/* [2] On vérifie que l'utilisateur n'est pas déjà créé
		=================================================================================================*/
		if( userRepo::UID($identifiant) ) // si on a un résultat, c'est qu'un utilisateur a déjà cet identifiant (UID)
			return false;

		/* [3] On créé le nouvel utilisateur
		=================================================================================================*/
		$creationUtilisateur = DataBase::getPDO()->prepare("INSERT INTO utilisateur(identifiant, prenom, nom, sexe, mail, mdp, droits)
			VALUES(:identifiant, :prenom, :nom, :sexe, :mail, :mdp, :droits)");
		$creationUtilisateur->execute(array(
			':identifiant' => $identifiant,
			':prenom'      => $prenom,
			':nom'         => $nom,
			':sexe'        => $sexe,
			':mail'        => $mail,
			':mdp'         => $mdp,
			':droits'      => $droits  
		));


		/* [4] On vérifie que l'utilisateur a bien été créé
		=================================================================================================*/
		return userRepo::UID($identifiant);

	}


	/* retourne l'UID d'un étudiant et le créé en amont s'il n'existe pas
	*
	* @identifiant<String>				l'UID de l'étudiant en question
	* @prenom<String>					le prénom de l'étudiant en question
	* @nom<String>						le nom de l'étudiant en question
	* @sexe<Boolean>					le sexe de l'étudiant en question
	* @mail<String>						le mail de l'étudiant en question
	*
	*
	* @return UID<String>				retourne l'UID de l'étudiant
	* @return FALSE<Boolean>			retourne FALSE si une erreur occure
	* 
	*/
	public static function includeEtudiant($identifiant, $prenom, $nom, $sexe, $mail){
		/* [1] On vérifie l'existence de l'étudiant (par identifiant uniquement)
		======================================================*/
		$getEtudiantUID = DataBase::getPDO()->prepare("SELECT identifiant as id
			FROM utilisateur
			WHERE identifiant = :identifiant");
		$getEtudiantUID->execute(array( ':identifiant' => $identifiant ));

		/* [2] Cas où l'étudiant existe déjà, alors on retourne l'UID
		======================================================*/
		if( $etudiantUID = $getEtudiantUID->fetch()['id'] ) return $etudiantUID;

		/* [3] Cas où l'étudiant n'existe pas, alors on le créé
		======================================================*/
		$creerSemestre = DataBase::getPDO()->prepare("INSERT INTO utilisateur(identifiant, prenom, nom, sexe, mail, mdp, droits)
			VALUES(:identifiant, :prenom, :nom, :sexe, :mail, DEFAULT, :droits)"); // par défaut le nom du semestre = "Sn" où n est le rang
		$creerSemestre->execute(array(
			':identifiant' => $identifiant,
			':prenom'      => $prenom,
			':nom'         => $nom,
			':sexe'        => $sexe,
			':mail'        => $mail,
			':droits'      => 'student'
		));

		/* [4] On vérifie que la formation a été créé et retourne son UID
		======================================================*/
		$getEtudiantUID = DataBase::getPDO()->prepare("SELECT identifiant as id
			FROM utilisateur
			WHERE identifiant = :identifiant");
		$getEtudiantUID->execute(array( ':identifiant' => $identifiant ));

		return $etudiantUID = $getEtudiantUID->fetch()['id'];
	}


	/**
	* Fonction search : recherche dans la bae de données un utilisateur
	* Pour se faire on recherche un mot clé contenu dans le nom ou le prénom de l'utilisateur
	*
	* @param $mot: le mot clé de la recherche associée
	* @return le tableau des résultats, ou false en cas d'erreur
	*==================================================================================================>
	*/
	public static function search($mot){
		//Vérification du paramètre:
		if (! checkParam($mot, '<string>')) {
			return false;
		}
		//On recherche dans la table utilisateur dans les noms et prénoms qui contiendraient une ccurence de "mot"
		$statement  = DataBase::getPDO()->prepare("SELECT * FROM utilisateur".
			" WHERE nom LIKE :nom OR :prenom OR nom = :mot OR prenom = :mot ;");
		$ret = $statement->execute(array(':nom'    => '%'.$mot.'%',
			                             ':prenom' => '%'.$mot.'%',
			                             ':mot'    => $mot));
		if($ret)
			return $statement->fetchAll();
		return false;
	}

}