Subversion Repositories eFlore/Applications.del

package org.tela_botanica.del.client.composants.votes.moyennevotes;

import java.util.Iterator;
import java.util.List;

import org.tela_botanica.del.client.cache.CacheClient;
import org.tela_botanica.del.client.modeles.Image;
import org.tela_botanica.del.client.modeles.Protocole;
import org.tela_botanica.del.client.modeles.VoteProtocole;
import org.tela_botanica.del.client.services.rest.VoteProtocoleService;
import org.tela_botanica.del.client.services.rest.VoteProtocoleServiceConcret;
import org.tela_botanica.del.client.services.rest.async.VoteProtocoleCallback;
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ClickHandler;
import com.google.gwt.event.dom.client.HasClickHandlers;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.HasText;
import com.google.gwt.user.client.ui.HasWidgets;
import com.google.gwt.user.client.ui.IsWidget;

public class MoyenneVotePresenteur {

        public interface Vue extends IsWidget {
                public HasClickHandlers getBoutonVoter();
                public HasClickHandlers getBoutonAnnuler();
                public HasText getNbVotes();
                public HasClickHandlers getVotes();
                public int getValeurVote();
                public void afficherBoutonVoter();
                public void afficherBoutonAnnuler();
                public void masquerBoutonVoter();
                public void masquerBoutonAnnuler();
                public void afficherNbVotes();
                public void masquerNbVotes();   
                public void reinitialiserVotes();
                public void rafraichir(int moyenneVote, int nbVotes);
                public void ajouterAuParent(HasWidgets composite);
        }
        
        private Vue vue;
        private Protocole protocole;
        private Image image;
        
        private int valeurVoteDefaut = -1;
        private int valeurVoteUtilisateur = -1;
        private int valeurVoteTotal = 0;
        
        //TODO: on devrait passer un conteneur qui permet d'accéder à ces services
        private VoteProtocoleService voteProtocoleService = new VoteProtocoleServiceConcret();
        
        public MoyenneVotePresenteur(Image image, Protocole protocole, Vue vue) {
                this.vue = vue;
                this.protocole = protocole;
                this.image = image;
        }

        public void go(HasWidgets composite) {
                vue.ajouterAuParent(composite);
                gererEvenements();
                rafraichirVue();
        }
        
        public void gererEvenements() {
                vue.getVotes().addClickHandler(new ClickHandler() {
                        @Override
                        public void onClick(ClickEvent event) {
                                valeurVoteUtilisateur = vue.getValeurVote();
                                vue.afficherBoutonVoter();
                                vue.afficherBoutonAnnuler();
                                vue.masquerNbVotes();
                        }
                });
                
                vue.getBoutonAnnuler().addClickHandler(new ClickHandler() {
                        @Override
                        public void onClick(ClickEvent event) {
                                valeurVoteUtilisateur = valeurVoteDefaut;
                                vue.masquerBoutonVoter();
                                vue.masquerBoutonAnnuler();
                                vue.afficherNbVotes();
                                vue.reinitialiserVotes();
                        }
                });
                
                vue.getBoutonVoter().addClickHandler(new ClickHandler() {
                        @Override
                        public void onClick(ClickEvent event) {
                                enregistrerVote();
                                vue.masquerBoutonVoter();
                                vue.masquerBoutonAnnuler();
                                vue.afficherNbVotes();
                                vue.reinitialiserVotes();
                        }
                });
        }
        
        public void setValeurVoteUtilisateur(int valeurVoteUtilisateur) {
                this.valeurVoteUtilisateur = valeurVoteUtilisateur;
        }
        
        public void enregistrerVote() {
                final VoteProtocole voteProtocole  = new VoteProtocole();
                voteProtocole.setProtocole(this.protocole);
                voteProtocole.setVote(valeurVoteUtilisateur);
                String idContributeur = CacheClient.getInstance().getUtilisateur().getId();
                voteProtocole.setContributeur(idContributeur);
                // TODO: Mettre un message de chargement pendant l'envoi du vote ?
                // C'est très rapide mais bon
                VoteProtocoleCallback vpc = new VoteProtocoleCallback() {
                        @Override
                        public void surRetour(String messageRetour) {
                                //TODO: voir si l'on affiche un message en cas de succès ?
                                image.ajouterVoteProtocole(voteProtocole);
                                rafraichirVue();
                        }
                        
                        @Override
                        public void surErreur(String messageErreur) {
                                Window.alert(messageErreur);
                        }
                };
                
                if(image.utilisateurAVotePourProtocole(this.protocole.getId()+"", idContributeur)) {
                        voteProtocoleService.modifierVote(image.getIdImage(), voteProtocole, vpc);
                } else {
                        voteProtocoleService.ajouterVote(image.getIdImage(), voteProtocole, vpc);
                }
        }
        
        public int getValeurVoteTotal() {
                return valeurVoteTotal;
        }

        public IsWidget getVue() {
                return vue;
        }
        
        private void rafraichirVue() {
                valeurVoteTotal = calculerMoyenneVotes();
                vue.rafraichir(valeurVoteTotal, image.getVotesProtocoles(protocole.getId()).size());
        }
        
        public int calculerMoyenneVotes() {
                double valeurVote = 0;
                int nbVote = 0;
                for (Iterator<String> iterator = image.getVotesProtocoles(protocole.getId()).keySet().iterator(); iterator.hasNext();) {
                        VoteProtocole imageCelValidationData = image.getVotesProtocoles(protocole.getId()).get(iterator.next());
                        valeurVote += (double)imageCelValidationData.getVote()/5;
                        nbVote++;
                }
                
                if (nbVote > 0) {
                        valeurVote /= nbVote;
                        valeurVote *= 5;
                }

                return (int)Math.round(valeurVote);
        }
}