package client;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import client.model.LienProblemeMethodeResultat;
import client.model.LienUserGroupRole;
import client.model.group.Groupe;
import client.model.user.Droits;
import client.model.user.Role;
import client.model.user.Utilisateur;

/**
 * <u><b>Explication générale de la classe :</b></u>
 * <P>
 * <P> Cette classe permet de créer des outils permettant de simplifier les
 * intéractions entre les données de l'application
 * 
 * @author Dream Team
 */
public final class ApplicationHelper {

	/**
	 * <u><i>Explication générale de la méthode :</i></u> <P> Cette méthode permet
	 * de vérifier si un utlisateur donné est dans un groupe
	 * 
	 * @param idUser
	 *            id de l'utilisateur en question
	 * @param idGroup
	 *            id du groupe en question
	 * 
	 * @return Vrai si l'utilisateur est dans le groupe sinon Faux
	 * 
	 */
	public static boolean UserIsInGroup(int idUser, int idGroup) {
		for (LienUserGroupRole l : Application.getInstance()
				.getArrayLinkOfUserGroupRole()) {
			if (l.getIdUser() == idUser && l.getIdGroup() == idGroup) {
				return true;
			}
		}
		return false;
	}

	/**
	 * <u><i>Explication générale de la méthode :</i></u> <P> Cette méthode permet
	 * de vérifier si un utilisaeur peut effectuer une action ou non
	 * 
	 * @param idUser
	 *            id de l'utilisateur en question
	 * @param idGroup
	 *            id du groupe en question
	 * @param right
	 *            droit à tester
	 * 
	 * @return Vrai si l'utilisateur peut effectuer ce droit dans ce groupe
	 *         sinon Faux
	 */
	public static boolean UserCan(int idUser, int idGroup, Integer right) {
		for (LienUserGroupRole l : Application.getInstance()
				.getArrayLinkOfUserGroupRole()) {
			if (l.getIdUser() == idUser && l.getIdGroup() == idGroup) {
				return Application.getInstance().getRole(l.getIdRole())
						.getDroits().contains(right);
			}
		}
		return false;
	}

	/**
	 * <u><i>Explication générale de la méthode :</i></u> <P> Cette méthode permet
	 * de vérifier si un role peut effectuer une action
	 * 
	 * @param idRole
	 *            role à tester
	 * @param right
	 *            droit à tester
	 * 
	 * @return Vrai si le role peut effectuer ce droit sinon Faux
	 */
	public static boolean ARoleCan(int idRole, Integer right) {
		System.out.println("right : " + right);
		System.out.print(Application.getInstance().getRole(idRole).getDroits());
		return Application.getInstance().getRole(idRole).getDroits().contains(
				right);
	}

	/**
	 * <u><i>Explication générale de la méthode :</i></u> <P> Cette méthode permet
	 * de vérifier si un role peut effectuer une action dans un groupe donné
	 * 
	 * @param idUser
	 *            id de l'utilisateur à tester
	 * @param idGroup
	 *            id du groupe à tester
	 * @param right
	 *            droit à tester
	 * 
	 * @return Vrai si ce rôle peut effectuer ce droit dans ce groupe
	 */
	public static boolean ARoleCanInGroup(int idUser, int idGroup, Integer right) {
		for (LienUserGroupRole l : Application.getInstance()
				.getArrayLinkOfUserGroupRole()) {
			if (l.getIdUser() == idUser && l.getIdGroup() == idGroup) {

				for (Iterator<Integer> i = Application.getInstance().getRole(
						l.getIdRole()).getDroits().iterator(); i.hasNext();) {
					if (i.next().equals(right))
						return true;
				}
				Application.getInstance().getRole(l.getIdRole()).getDroits()
						.contains(right);
			}
		}
		return false;
	}

	/**
	 * <u><i>Explication générale de la méthode :</i></u> <P> Cette méthode permet
	 * de vérifier si un User a le bon role dans un groupe et donc de lui
	 * permettre d'accéder aux fonctionnalités
	 * 
	 * @param idUser
	 *            id de l'utilisateur à tester
	 * @param idGroup
	 *            id du groupe à tester
	 * @param roleAComparer
	 *            role à tester
	 * 
	 * @return Vrai si cet utilisateur a le bon rôle dans ce groupe
	 */
	public static boolean UserHaveGoodRole(int idUser, int idGroup,
			Role roleAComparer) {
		for (LienUserGroupRole l : Application.getInstance()
				.getArrayLinkOfUserGroupRole()) {
			if (l.getIdUser() == idUser && l.getIdGroup() == idGroup) {
				return Application.getInstance().getRole(l.getIdRole()).equals(
						roleAComparer);
			}
		}
		return false;
	}

	/**
	 * <u><i>Explication générale de la méthode :</i></u> <P> Cette méthode permet
	 * de vérifier si un User a le bon role dans un groupe et donc de lui
	 * permettre d'accéder aux fonctionnalités
	 * 
	 * @param idUser
	 *            id de l'utilisateur à tester
	 * @param idGroup
	 *            id du groupe à tester
	 * @param idRole
	 *            id du role à tester
	 * 
	 * @return Vrai si cet utilisateur a le bon rôle dans ce groupe
	 */
	public static boolean UserHaveGoodRole(int idUser, int idGroup, int idRole) {
		for (LienUserGroupRole l : Application.getInstance()
				.getArrayLinkOfUserGroupRole()) {
			if (l.getIdUser() == idUser && l.getIdGroup() == idGroup
					&& l.getIdRole() == idRole) {
				return true;
			}
		}
		return false;
	}

	/**
	 * <u><i>Explication générale de la méthode :</i></u> <P> Cette méthode permet
	 * de vérifier si un User a le role comparé
	 * 
	 * @param idUser
	 *            id de l'utilisateur à tester
	 * @param roleAComparer
	 *            role à tester
	 * 
	 * @return Vrai si cet utilisateur a le bon rôle dans ce groupe
	 */
	public static boolean UserHaveGoodRole(int idUser, Role roleAComparer) {
		if (Application.getInstance().getUser(idUser).getRolePersonne().equals(
				roleAComparer)) {
			return true;
		}
		return false;
	}

	/**
	 * <u><i>Explication générale de la méthode :</i></u> <P> Cette méthode permet
	 * de vérifier si un User est l'admin
	 * 
	 * @param idUser
	 *            id de l'utilisateur à tester
	 * @param idRole
	 *            id du role à tester
	 * 
	 * @return Vrai si l'utilisateur est un admin sinon Faux
	 */
	public static boolean UserIsAdmin(int idUser, int idRole) {
		if (Application.getInstance().getUser(idUser).getRolePersonne() == null) {
			System.out.println("role null");
			return false;
		} else if (Application.getInstance().getIdRole(
				Application.getInstance().getUser(idUser).getRolePersonne()
						.getNomRole()) == idRole) {
			System.out.println("role : "
					+ Application.getInstance().getUser(idUser)
							.getRolePersonne().getNomRole());
			return true;
		}
		return false;
	}

	/**
	 * <u><i>Explication générale de la méthode :</i></u> <P> Cette méthode permet
	 * de savoir si un role possède au moins un droit de l'admin
	 * 
	 * @param role
	 *            Role à tester
	 * 
	 * @return Vrai si l'utilisateur posède au moins un droit sinon Faux
	 */
	public static boolean UserHaveRightOfAdmin(Role role) {

		int idRole = Application.getInstance().getIdRole(role);

		System.out.println("Droits dans UserHave Admin : "
				+ Application.getInstance().getRole(idRole).getDroits());
		if ((Application.getInstance().getRole(idRole).getDroits()
				.contains(Droits.CREER_GROUPE))
				|| (Application.getInstance().getRole(idRole).getDroits()
						.contains(Droits.CREER_MEMBRE))
				|| (Application.getInstance().getRole(idRole).getDroits()
						.contains(Droits.MODIFIER_GROUPE))
				|| (Application.getInstance().getRole(idRole).getDroits()
						.contains(Droits.MODIFIER_MEMBRE))
				|| (Application.getInstance().getRole(idRole).getDroits()
						.contains(Droits.SUPPRIMER_MEMBRE))
				|| (Application.getInstance().getRole(idRole).getDroits()
						.contains(Droits.SUPPRIMER_GROUPE))
				|| (Application.getInstance().getRole(idRole).getDroits()
						.contains(Droits.ASSIGNER_ROLE))) {
			return true;
		}
		return false;
	}

	/**
	 * <u><i>Explication générale de la méthode :</i></u> <P> Cette méthode permet
	 * de savoir si un role possède au moins un droit de l'admin
	 * 
	 * @param idUser
	 *            id de l'utilisateur à tester
	 * @param idGroup
	 *            id du groupe à tester
	 * 
	 * @return Vrai si l'utilisateur posède au moins un droit sinon Faux
	 */
	public static boolean UserHaveRightOfRespo(int idUser, int idGroup) {

		for (LienUserGroupRole l : Application.getInstance()
				.getArrayLinkOfUserGroupRole()) {
			if (l.getIdUser() == idUser && l.getIdGroup() == idGroup) {

				int idRole = l.getIdRole();
				System.out
						.println("Droits dans UserHave Respo : "
								+ Application.getInstance().getRole(idRole)
										.getDroits());
				if ((Application.getInstance().getRole(idRole).getDroits()
						.contains(Droits.ACCEPTER_MEMBRE_GROUPE))
						|| (Application.getInstance().getRole(idRole)
								.getDroits()
								.contains(Droits.REFUSER_MEMBRE_GROUPE))
						|| (Application.getInstance().getRole(idRole)
								.getDroits()
								.contains(Droits.EXCLURE_MEMBRE_GROUPE))) {
					return true;
				}
			}
		}
		return false;
	}

	/**
	 * <u><i>Explication générale de la méthode :</i></u> <P> Cette méthode permet
	 * de savoir si un utilisateur existe déjà dans le cache
	 * 
	 * @param user
	 *            utilisateur à tester
	 * 
	 * @return Vrai si l'utilisateur existe
	 */
	public static boolean UserExists(Utilisateur user) {
		for (int i = 0; i < Application.getInstance().sizeOfArrayUser(); i++) {
			if (Application.getInstance().getUser(i).equals(user))
				return true;
		}
		return false;
	}

	/**
	 * <u><i>Explication générale de la méthode :</i></u> <P> Cette méthode permet
	 * de vérifier si un utilisateur vérifie les données de l'IHM
	 * 
	 * @param idUser
	 *            id de l'utilisateur à tester
	 * @param loginAComparer
	 *            login à comparer venant de l'IHM
	 * @param passwordAComparer
	 *            password à comparer venant de l'IHM
	 * 
	 * @return Vrai si les données correspondent à un utilisateur
	 */
	public static boolean VerifyUserConnection(int idUser,
			String loginAComparer, String passwordAComparer) {
		if (Application.getInstance().getUser(idUser).getLogin().equals(
				loginAComparer)
				&& Application.getInstance().getUser(idUser).getPassword()
						.equals(passwordAComparer)) {
			return true;
		}
		return false;
	}

	/**
	 * <u><i>Explication générale de la méthode :</i></u> <P> Cette méthode permet
	 * de changer de role dans un groupe
	 * 
	 * @param idUser
	 *            id de l'utilisateur testé
	 * @param idGroup
	 *            id du groupe testé
	 * @param idOldRole
	 *            id de l'ancien rôle
	 * @param idNewRole
	 *            id du nouveau rôle
	 */
	public static void ChangeRole(int idUser, int idGroup, int idOldRole,
			int idNewRole) {
		for (LienUserGroupRole l : Application.getInstance()
				.getArrayLinkOfUserGroupRole()) {
			if (l.getIdUser() == idUser && l.getIdGroup() == idGroup
					&& l.getIdRole() == idOldRole) {
				l.setIdRole(idNewRole);
			}
		}
	}

	/**
	 * <u><i>Explication générale de la méthode :</i></u> <P> Cette méthode permet
	 * de changer d'admin
	 * 
	 * @param idNewUser
	 *            id de l'utilisateur qu'on met en admin
	 * @param idOldAdmin
	 *            id de l'ancien utilisateur qu'on met en membre
	 */
	public static void ChangeAdmin(int idNewUser, int idOldAdmin) {

		// On recupère tous les groupes de l'admin!
		Map<Integer, Groupe> groupsOfAdmin = GroupsOfUser(idOldAdmin);

		// On ajoute au nouvel utlisateur les groupes de l'admin
		for (Iterator<Groupe> i = groupsOfAdmin.values().iterator(); i
				.hasNext();) {
			int idGroup = i.next().getIdGroupe();
			if (!UserIsInGroup(idNewUser, idGroup)) {
				Application.getInstance().getArrayLinkOfUserGroupRole().add(
						new LienUserGroupRole(idNewUser, idGroup,
								Role.IDADMINISTRATEUR));
			}
		}

		// On change les id entre les deux users
		for (LienUserGroupRole l : Application.getInstance()
				.getArrayLinkOfUserGroupRole()) {

			// Le nouvel user est mis en tant qu'administrateur
			if (l.getIdUser() == idNewUser) {
				l.setIdRole(Role.IDADMINISTRATEUR);
			}

			// L'ancien user est mis en tant que membre
			if (l.getIdUser() == idOldAdmin) {
				l.setIdRole(Role.IDMEMBRE);
			}
		}

		// On affecte le rôle général ADMIN au nouvel user
		Application.getInstance().getUser(idNewUser).setRolePersonne(
				new Role(Role.ADMINISTRATEUR));

		// On enlève le rôle général ADMIN à l'ancien user
		Application.getInstance().getUser(idOldAdmin).setRolePersonne(null);
	}

	/**
	 * <u><i>Explication générale de la méthode :</i></u> <P> Cette méthode permet
	 * de savoir quels groupes les utilisateurs n'appartiennent pas
	 * 
	 * @param idUser
	 *            id de l'utilisateur à tester
	 * 
	 * @return l'array des groupes dans lequel l'utilisateur n'y est pas
	 * 
	 */
	public static ArrayList<Groupe> NoGroupsOfUser(int idUser) {
		ArrayList<Groupe> arrayNoGroupsOfUser = new ArrayList<Groupe>();
		Map<Integer, Groupe> arrayGroupsOfUserSelected = GroupsOfUser(idUser);

		for (int i = 0; i < Application.getInstance().sizeOfArrayGroup(); i++) {
			if (!arrayGroupsOfUserSelected.containsValue(Application
					.getInstance().getGroupe(i))) {
				arrayNoGroupsOfUser.add(Application.getInstance().getGroupe(i));
			}
		}
		return arrayNoGroupsOfUser;
	}

	/**
	 * <u><i>Explication générale de la méthode :</i></u> <P> Cette méthode permet
	 * de récupérer les groupes d'un utilisateur
	 * 
	 * @param idUser
	 *            id de l'utilisateur à tester
	 * 
	 * @return l'array des groupes d'un utilisateur
	 */
	public static Map<Integer, Groupe> GroupsOfUser(int idUser) {
		ArrayList<Integer> arrayIdGroup = new ArrayList<Integer>();

		// On recupère les id du groupe
		for (LienUserGroupRole l : Application.getInstance()
				.getArrayLinkOfUserGroupRole()) {
			if (l.getIdUser() == idUser) {
				arrayIdGroup.add(l.getIdGroup());
			}
		}

		System.out.println("arrayIdGroup : " + arrayIdGroup.size());
		System.out.println("arrayAllGroup : "
				+ Application.getInstance().sizeOfArrayGroup());

		// On recupère les groupes associés
		Map<Integer, Groupe> arrayGroupsOfUser = new HashMap<Integer, Groupe>();
		for (int i = 0; i < arrayIdGroup.size(); i++) {
			arrayGroupsOfUser.put(arrayIdGroup.get(i), Application
					.getInstance().getGroupe(arrayIdGroup.get(i)));
			System.out.println("id des groupes : "
					+ Application.getInstance().getGroupe(arrayIdGroup.get(i))
							.getIdGroupe());
		}

		return arrayGroupsOfUser;
	}

	/**
	 * <u><i>Explication générale de la méthode :</i></u> <P> Cette méthode permet
	 * de récupérer les utilisateurs d'un groupe
	 * 
	 * @param idGroup
	 *            id du groupe à tester
	 * 
	 * @return l'array des utilisateurs
	 */
	public static Map<Integer, Utilisateur> UsersOfGroup(int idGroup) {
		ArrayList<Integer> arrayIdUser = new ArrayList<Integer>();

		System.out.println("efbzebfhzeb");

		// On recupère les id du groupe
		for (LienUserGroupRole l : Application.getInstance()
				.getArrayLinkOfUserGroupRole()) {
			if (l.getIdGroup() == idGroup) {
				arrayIdUser.add(l.getIdUser());
			}
		}

		System.out.println("arrayIdUser : " + arrayIdUser.size());

		// On recupère les groupes associés
		Map<Integer, Utilisateur> arrayUsersOfGroup = new HashMap<Integer, Utilisateur>();

		for (int i = 0; i < arrayIdUser.size(); i++) {
			arrayUsersOfGroup.put(arrayIdUser.get(i), Application.getInstance()
					.getUser(arrayIdUser.get(i)));
		}

		return arrayUsersOfGroup;
	}

	/**
	 * <u><i>Explication générale de la méthode :</i></u> <P> Cette méthode permet
	 * d'autoriser la suppression ou non d'un groupe
	 * 
	 * @param idGroup
	 *            id du groupe à tester
	 * 
	 * @return Vrai si aucun souci sinon Faux
	 */
	public static boolean CanRemoveGroup(int idGroup) {
		Map<Integer, Utilisateur> arrayUsersOfGroup = ApplicationHelper
				.UsersOfGroup(idGroup);

		for (Iterator<Utilisateur> i = arrayUsersOfGroup.values().iterator(); i
				.hasNext();) {
			Map<Integer, Groupe> arrayGroupsOfUser = ApplicationHelper
					.GroupsOfUser(i.next().getIdPersonne());

			if (arrayGroupsOfUser.size() == 1) {
				return false;
			}
		}
		return true;
	}

	/**
	 * <u><i>Explication générale de la méthode :</i></u> <P> Cette méthode permet
	 * de vérifier si l'on peut supprimer un utilisateur
	 * 
	 * @param idUser
	 *            id de l'utilisateur à tester
	 * 
	 * @return Vrai si l'on peut le supprimer sinon Faux
	 */
	public static boolean CanRemoveUser(int idUser) {
		Map<Integer, Groupe> arrayGroupsOfUser = ApplicationHelper
				.GroupsOfUser(idUser);
		System.out.println("arrayGroupsOfUser : " + arrayGroupsOfUser.size());
		for (Iterator<Groupe> i = arrayGroupsOfUser.values().iterator(); i
				.hasNext();) {

			Groupe g = i.next();

			System.out.println("" + g.getNomGroupe());

			Map<Integer, Utilisateur> arrayUsersOfGroup = ApplicationHelper
					.UsersOfGroup(g.getIdGroupe());
			int idRole = IdRoleOfUserInGroup(idUser, Application.getInstance()
					.getIdGroupe(g.getNomGroupe()));

			System.out.println("size of arrayUserOfGroup : "
					+ arrayUsersOfGroup.size());

			if (arrayUsersOfGroup.size() == 1)
				return false;
			if (idRole == Role.IDRESPONSABLE) {
				return false;
			}
		}
		return true;
	}

	/**
	 * <u><i>Explication générale de la méthode :</i></u> <P> Cette méthode permet
	 * de vérifier si l'on peut kicker un utilisateur
	 * 
	 * @param idUser
	 *            id de l'utilisateur à tester
	 * @param idGroup
	 *            id du groupe à tester
	 * 
	 * @return Vrai si l'on peut le kicker sinon Faux
	 */
	public static boolean CanKickUser(int idUser, int idGroup) {

		Map<Integer, Utilisateur> arrayUsersOfGroup = ApplicationHelper
				.UsersOfGroup(idGroup);
		Map<Integer, Groupe> arrayGroupsOfUser = ApplicationHelper
				.GroupsOfUser(idUser);

		if (arrayUsersOfGroup.size() == 1 || arrayGroupsOfUser.size() == 1) {
			return false;
		}
		return true;
	}

	/**
	 * <u><i>Explication générale de la méthode :</i></u> <P> Cette méthode permet
	 * d'ajouter une ligne dans le tableau de triplet utilisateur/groupe/role
	 * 
	 * @param idUser
	 *            id de l'utilisateur à ajouter
	 * @param idGroup
	 *            id du groupe à ajouter
	 * @param idRole
	 *            id du role à ajouter
	 * 
	 */
	public static void AddLienUserGroupRole(int idUser, int idGroup, int idRole) {
		Application.getInstance().getArrayLinkOfUserGroupRole().add(
				new LienUserGroupRole(idUser, idGroup, idRole));
	}

	/**
	 * <u><i>Explication générale de la méthode :</i></u> <P> Cette méthode permet
	 * d'ajouter une ligne dans le tableau de triplet probleme/methode/resultat
	 * 
	 * @param idProbleme
	 *            id du problème à ajouter
	 * @param idMethode
	 *            id de la méthode à ajouter
	 * @param idResultat
	 *            id du resultat à ajouter
	 * 
	 */
	public static void AddLienProblemeMethodeResultat(int idProbleme,
			int idMethode, int idResultat) {
		Application.getInstance().getArrayLinkOfProblemeMethodeResultats().add(
				new LienProblemeMethodeResultat(idProbleme, idMethode,
						idResultat));
	}

	/**
	 * <u><i>Explication générale de la méthode :</i></u> <P> Cette méthode permet
	 * de supprimer un utilisateur à partir d'un groupe
	 * 
	 * @param idUser
	 *            id de l'utilisateur à tester
	 * @param idGroup
	 *            id du groupe à tester
	 * 
	 */
	public static void RemoveUserFromGroup(int idUser, int idGroup) {
		ArrayList<LienUserGroupRole> link = Application.getInstance()
				.getArrayLinkOfUserGroupRole();

		for (int i = 0; i < link.size();) {
			if (link.get(i).getIdUser() == idUser
					&& link.get(i).getIdGroup() == idGroup) {
				link.remove(i);
			} else {
				i++;
			}
		}
	}

	/**
	 * <u><i>Explication générale de la méthode :</i></u> <P> Cette méthode permet
	 * de supprimer un groupe
	 * 
	 * @param idGroup
	 *            id du groupe à tester
	 * 
	 */
	public static void RemoveGroupFromArrayLink(int idGroup) {
		ArrayList<LienUserGroupRole> link = Application.getInstance()
				.getArrayLinkOfUserGroupRole();

		for (int i = 0; i < link.size();) {
			if (link.get(i).getIdGroup() == idGroup) {
				link.remove(i);
			} else {
				i++;
			}
		}

	}

	/**
	 * <u><i>Explication générale de la méthode :</i></u> <P> Cette méthode permet
	 * de supprimer un utilisateur
	 * 
	 * @param idUser
	 *            id de l'utilisateur à tester
	 * 
	 */
	public static void RemoveUserFromArrayLink(int idUser) {
		ArrayList<LienUserGroupRole> link = Application.getInstance()
				.getArrayLinkOfUserGroupRole();

		for (int i = 0; i < link.size();) {
			if (link.get(i).getIdUser() == idUser) {
				link.remove(i);
			} else {
				i++;
			}
		}
	}

	/**
	 * <u><i>Explication générale de la méthode :</i></u> <P> Cette méthode permet
	 * de supprimer un problème
	 * 
	 * @param idProblem
	 *            id du problème
	 * 
	 */
	public static void RemoveProblemeFromArrayLink(int idProblem) {
		ArrayList<LienProblemeMethodeResultat> link = Application.getInstance()
				.getArrayLinkOfProblemeMethodeResultats();

		for (int i = 0; i < link.size();) {
			if (link.get(i).getIdProbleme() == idProblem) {
				link.remove(i);
			} else {
				i++;
			}
		}
	}

	/**
	 * <u><i>Explication générale de la méthode :</i></u> <P> Cette méthode permet
	 * de récupérer l'id du rôle d'un utilisateur dans son groupe
	 * 
	 * @param idUser
	 *            id de l'utilisateur à tester
	 * @param idGroup
	 *            id du groupe à tester
	 * 
	 */
	public static int IdRoleOfUserInGroup(int idUser, int idGroup) {
		for (LienUserGroupRole l : Application.getInstance()
				.getArrayLinkOfUserGroupRole()) {
			if (l.getIdUser() == idUser && l.getIdGroup() == idGroup) {
				return l.getIdRole();
			}
		}
		return -1;
	}

	/**
	 * <u><i>Explication générale de la méthode :</i></u> <P> Cette méthode permet
	 * de récupérer l'id d'un utilisateur à partir de son rôle dans un groupe
	 * 
	 * @param idGroup
	 *            id du groupe à tester
	 * @param idRole
	 *            id du rôle à tester
	 * 
	 */
	public static int idUserOfRoleInGroup(int idGroup, int idRole) {
		for (LienUserGroupRole l : Application.getInstance()
				.getArrayLinkOfUserGroupRole()) {
			if (l.getIdGroup() == idGroup && l.getIdRole() == idRole) {
				return l.getIdUser();
			}
		}
		return -1;
	}

	/**
	 * <u><i>Explication générale de la méthode :</i></u> <P> Cette méthode permet
	 * de récupérer l'id d'un résultat à partir d'un problème
	 * 
	 * @param idProblem
	 *            id du problème à tester
	 * @param idMethod
	 *            id de la méthode à tester
	 * 
	 * @return id du résultat recherché
	 * 
	 */

	public static int idResultOfProblem(int idProblem, int idMethod) {
		for (LienProblemeMethodeResultat l : Application.getInstance()
				.getArrayLinkOfProblemeMethodeResultats()) {
			if (l.getIdProbleme() == idProblem && l.getIdMethode() == idMethod) {
				return l.getIdResultat();
			}
		}
		return -1;
	}
}