package reseau;

import client.model.benchmark.Benchmarks;
import client.model.group.Groupe;
import client.model.problem.Probleme;
import client.model.problem.Resultat;
import client.model.user.Utilisateur;

/**
 * Interface décrivant les opérations CRUD permises sur la base de données
 * Facade déstiné à être utilisé par les classes clientes afin d'abstraire les mécanismes réseaux
 *
 * @author Andréa
 */
public interface IDatabaseOperationsProxyFacade {

    /**
     * Crée un utilisateur en base de données
     *
     *
     * @param userid   Id de l'utilisateur effectuant l'action.
     * @param template objet décrivant la donnée à créer<br/>
     *                 Le champ <code>id</code> sera modifié selon la réponse du serveur !
     * @return Objet créé
     * @throws UnauthorizedOperationException L'utilisateur n'a pas le droit d'effectuer cette opération
     */
    public Utilisateur createUser(int userid, Utilisateur template) throws UnauthorizedOperationException;

    /**
     * Crée un groupe en base de données
     *
     * @param userid   Id de l'utilisateur effectuant l'action.
     * @param template objet décrivant la donnée à créer<br/>
     *                 Le champ <code>id</code> sera modifié selon la réponse du serveur !
     * @return Objet créé
     * @throws UnauthorizedOperationException L'utilisateur n'a pas le droit d'effectuer cette opération
     */
    public Groupe createGroup(int userid, Groupe template) throws UnauthorizedOperationException;

    /**
     * Crée un groupe en base de données
     *
     * @param userid   Id de l'utilisateur effectuant l'action.
     * @param groupid  Id du groupe au sein duquel l'opération est effectuée.
     * @param template objet décrivant la donnée à créer<br/>
     *                 Le champ <code>id</code> sera modifié selon la réponse du serveur !
     * @return Objet créé
     * @throws UnauthorizedOperationException L'utilisateur n'a pas le droit d'effectuer cette opération
     */
    public Probleme createProblem(int userid, int groupid, Probleme template) throws UnauthorizedOperationException;
    
    /**
     * Créer un benchmark imprimable
     *
     * @param template benchmark à imprimer
     */
    public void createPrintBenchmark(Benchmarks template);

    /**
     * Récupère un utilisateur en base de données
     *
     *
     * @param userid       Id de l'utilisateur effectuant l'action.
     * @param searchuserid Id de l'utilisateur recherché
     * @return L'utilisateur correspondant
     * @throws DataNotFoundException          Si la donnée demandée n'existe pas
     * @throws UnauthorizedOperationException L'utilisateur n'a pas le droit d'effectuer cette opération
     */
    public Utilisateur readUser(int userid, int searchuserid) throws DataNotFoundException, UnauthorizedOperationException;

    /**
     * Récupère un groupe en base de données
     *
     * @param searchedgroupid Id du groupe recherché
     * @return Le groupe correspondant
     * @throws DataNotFoundException          Si la donnée demandée n'existe pas
     */
    public Groupe readGroupe(int searchedgroupid) throws DataNotFoundException;

    /**
     * Récupère un problème en base de données
     *
     * @param userid            Id de l'utilisateur effectuant l'action.
     * @param groupid           Id du groupe au sein duquel l'opération est effectuée.
     * @param searchedproblemid Id du problème recherché
     * @return Le problème correspondant
     * @throws DataNotFoundException          Si la donnée demandée n'existe pas
     * @throws UnauthorizedOperationException L'utilisateur n'a pas le droit d'effectuer cette opération
     */
    public Probleme readProblem(int userid, int groupid, int searchedproblemid) throws DataNotFoundException, UnauthorizedOperationException;

    /**
     * Récupère un résultat en base de données
     *
     * @param userid           Id de l'utilisateur effectuant l'action.
     * @param groupid          Id du groupe au sein duquel l'opération est effectuée.
     * @param searchedresultid Id du résultat recherché
     * @return Le résultat correspondant
     * @throws DataNotFoundException          Si la donnée demandée n'existe pas
     * @throws UnauthorizedOperationException L'utilisateur n'a pas le droit d'effectuer cette opération
     */
    public Resultat readResult(int userid, int groupid, int searchedresultid) throws DataNotFoundException, UnauthorizedOperationException;

    /**
     * Récupère un benchmark en base de données
     *
     * @param userid              Id de l'utilisateur effectuant l'action.
     * @param groupid             Id du groupe au sein duquel l'opération est effectuée.
     * @param searchedbenchmarkid Id du benchmark recherché
     * @return Le benchmark correspondant
     * @throws DataNotFoundException          Si la donnée demandée n'existe pas
     * @throws UnauthorizedOperationException L'utilisateur n'a pas le droit d'effectuer cette opération
     */
    public Benchmarks readBenchmark(int userid, int groupid, int searchedbenchmarkid) throws DataNotFoundException, UnauthorizedOperationException;

    /**
     * Actualise un utilisateur en base de données
     *
     * @param userid   Id de l'utilisateur effectuant l'action.
     * @param groupid  Id du groupe au sein duquel l'opération est effectuée.
     * @param template utilisateur décrivant la donnée à actualiser<br/>
     * @return Le nouvel utilisateur
     * @throws DataNotFoundException          Si la donnée demandée n'existe pas
     * @throws UnauthorizedOperationException L'utilisateur n'a pas le droit d'effectuer cette opération
     */
    public Utilisateur updateUser(int userid, int groupid, Utilisateur template) throws DataNotFoundException, UnauthorizedOperationException;

    /**
     * Actualise un groupe en base de données
     *
     * @param userid   Id de l'utilisateur effectuant l'action.
     * @param groupid  Id du groupe au sein duquel l'opération est effectuée.
     * @param template groupe décrivant la donnée à actualiser<br/>
     * @return Le nouveau groupe
     * @throws DataNotFoundException          Si la donnée demandée n'existe pas
     * @throws UnauthorizedOperationException L'utilisateur n'a pas le droit d'effectuer cette opération
     */
    public Groupe updateGroup(int userid, int groupid, Groupe template) throws DataNotFoundException, UnauthorizedOperationException;

    /**
     * Actualise un problème en base de données
     *
     * @param userid   Id de l'utilisateur effectuant l'action.
     * @param groupid  Id du groupe au sein duquel l'opération est effectuée.
     * @param template problème décrivant la donnée à actualiser<br/>
     * @return Le nouveau problème
     * @throws DataNotFoundException          Si la donnée demandée n'existe pas
     * @throws UnauthorizedOperationException L'utilisateur n'a pas le droit d'effectuer cette opération
     */
    public Probleme updateProblem(int userid, int groupid, Probleme template) throws DataNotFoundException, UnauthorizedOperationException;

    /**
     * Supprime un utilisateur de la base de données
     *
     * @param userid       Id de l'utilisateur effectuant l'action.
     * @param targetuserid Id de l'utilisateur à supprimer
     * @throws DataNotFoundException          Si la donnée demandée n'existe pas
     * @throws UnauthorizedOperationException L'utilisateur n'a pas le droit d'effectuer cette opération
     */
    public void deleteUser(int userid, int targetuserid) throws DataNotFoundException, UnauthorizedOperationException;

    /**
     * Supprime un groupe de la base de données
     *
     * @param userid        Id de l'utilisateur effectuant l'action.
     * @param targetgroupid Id du groupe à supprimer
     * @throws DataNotFoundException          Si la donnée demandée n'existe pas
     * @throws UnauthorizedOperationException L'utilisateur n'a pas le droit d'effectuer cette opération
     */
    public void deleteGroup(int userid, int targetgroupid) throws DataNotFoundException, UnauthorizedOperationException;

    /**
     * Supprime un problème de la base de données
     *
     * @param userid          Id de l'utilisateur effectuant l'action.
     * @param groupid         Id du groupe au sein duquel l'opération est effectuée.
     * @param targetproblemid Id du problème à supprimer
     * @throws DataNotFoundException          Si la donnée demandée n'existe pas
     * @throws UnauthorizedOperationException L'utilisateur n'a pas le droit d'effectuer cette opération
     */
    public void deleteProblem(int userid, int groupid, int targetproblemid) throws DataNotFoundException, UnauthorizedOperationException;

    /**
     * Supprime un résultat de la base de données
     *
     * @param userid         Id de l'utilisateur effectuant l'action.
     * @param groupid        Id du groupe au sein duquel l'opération est effectuée.
     * @param targetresultid Id du résultat à supprimer
     * @throws DataNotFoundException          Si la donnée demandée n'existe pas
     * @throws UnauthorizedOperationException L'utilisateur n'a pas le droit d'effectuer cette opération
     */
    public void deleteResult(int userid, int groupid, int targetresultid) throws DataNotFoundException, UnauthorizedOperationException;

    /**
     * Supprime un benchmark de la base de données
     *
     * @param userid            Id de l'utilisateur effectuant l'action.
     * @param groupid           Id du groupe au sein duquel l'opération est effectuée.
     * @param targetbenchmarkid Id du benchmark à supprimer
     * @throws DataNotFoundException          Si la donnée demandée n'existe pas
     * @throws UnauthorizedOperationException L'utilisateur n'a pas le droit d'effectuer cette opération
     */
    public void deleteBenchmark(int userid, int groupid, int targetbenchmarkid) throws DataNotFoundException, UnauthorizedOperationException;

}