Subversion Repositories eFlore/Applications.del

package org.tela_botanica.del.client.vues.rechercheimages.resultats.images;

import java.util.List;

import org.tela_botanica.del.client.cache.CacheClient;
import org.tela_botanica.del.client.composants.fenetreOverlayDefilante.FenetreOverlayDefilantePresenteur;
import org.tela_botanica.del.client.composants.fenetreOverlayDefilante.FenetreOverlayDefilanteVue;
import org.tela_botanica.del.client.composants.presenteur.Presenteur;
import org.tela_botanica.del.client.modeles.Image;
import org.tela_botanica.del.client.modeles.ImageServiceResultat;
import org.tela_botanica.del.client.modeles.Observation;
import org.tela_botanica.del.client.modeles.Protocole;
import org.tela_botanica.del.client.modeles.VoteProtocole;
import org.tela_botanica.del.client.navigation.evenement.BusEvenementiel;
import org.tela_botanica.del.client.navigation.evenement.changementprotocole.EvenementChangementProtocole;
import org.tela_botanica.del.client.navigation.evenement.changementprotocole.GestionnaireEvenementChangementProtocole;
import org.tela_botanica.del.client.navigation.evenement.rechercheimage.EvenementVoirDetailsImage;
import org.tela_botanica.del.client.navigation.evenement.rechercheimage.GestionnaireEvenementVoirDetailsImage;
import org.tela_botanica.del.client.navigation.evenement.validationobservation.EvenementValidation;
import org.tela_botanica.del.client.services.rest.ImageService;
import org.tela_botanica.del.client.services.rest.ImageServiceConcret;
import org.tela_botanica.del.client.services.rest.async.ImagesParTaxonCallback;
import org.tela_botanica.del.client.utils.MockDatasource;
import org.tela_botanica.del.client.vues.rechercheimages.vote.MoyenneVotePresenteur;
import org.tela_botanica.del.client.vues.rechercheobservations.DetailImagePresenteur;
import org.tela_botanica.del.client.vues.rechercheobservations.DetailImageVue;

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.ui.HasWidgets;
import com.google.gwt.user.client.ui.IsWidget;

public class ImagePresenteur extends Presenteur {

        public interface Vue extends IsWidget {

                public abstract void loadImage(Image image);

                public abstract HasClickHandlers getImagePrincipale();
                
                public IsWidget getImagePrincipaleWidget();
                
                public void setUrlImagePrincipale(String url);

                public void setTitreImagePrincipale(String titre);

                public void setAltTextImagePrincipale(String altText);

                public String getUrlImagePrincipale();

                public String getTitreImagePrincipale();

                public String getAltTextImagePrincipale();

                public abstract HasClickHandlers getEnSavoirPlus();

                public abstract HasClickHandlers getZoom();

                public abstract void cacherZoneCache();

                public abstract void afficherZoneCache();

                public abstract HasWidgets getZoneVoter();

                public HasClickHandlers getNomAuteur();
                
                public HasClickHandlers getNomEspece();
        }

        private Vue vue;

        private final MockDatasource validationService = MockDatasource.getInstance();
        private final Image image;
        private boolean detailsOpen = false;

        private Protocole protocole;

        public ImagePresenteur(Image image, Protocole protocole, Vue vue) {
                this.image = image;
                this.protocole = protocole;
                this.vue = vue;
        }

        public void go(HasWidgets composite) {
                composite.add(vue.asWidget());
                vue.loadImage(image);
                loadValidationData();
                gererEvenements();
        }

        private void loadValidationData() {
                vue.getZoneVoter().clear();
                List<VoteProtocole> observationValidationDatas = validationService.getVoteByImageAndProtocol(image.getIdImage(), protocole.getNom());
                new MoyenneVotePresenteur(observationValidationDatas, image.getIdImage(), protocole).go(vue.getZoneVoter());
                
        }

        private void lancerEvenementValidation() {
                CacheClient.getInstance().setImageCourante(image);
                final Observation obs = image.getObservation();

                // charge toutes les images de l'observation associee à l'observation en
                // cours
                ImageService imageService = new ImageServiceConcret();
                imageService.getImagesParObservation(obs.getId(), new ImagesParTaxonCallback() {

                        @Override
                        public void surImagesRecues(ImageServiceResultat imagesRecues) {
                                
                                //TODO a changer lorsque le service sera implementé de manière realiste
                                //par obs.setImages(imagesRecues.getImages());
                                obs.getImages().addAll(imagesRecues.getImages().subList(0, 9));
                                BusEvenementiel.getInstance().fireEvent(new EvenementValidation(obs));
                        }
                });

        }
        
        protected void gererEvenements() {
                vue.getImagePrincipale().addClickHandler(new ClickHandler() {
                        public void onClick(ClickEvent event) {
                                lancerEvenementValidation();
                        }
                });

                vue.getNomAuteur().addClickHandler(new ClickHandler() {
                        public void onClick(ClickEvent event) {
                                lancerEvenementValidation();
                        }
                });
                
                vue.getNomEspece().addClickHandler(new ClickHandler() {
                        public void onClick(ClickEvent event) {
                                lancerEvenementValidation();
                        }
                });
                
                vue.getEnSavoirPlus().addClickHandler(new ClickHandler() {

                        @Override
                        public void onClick(ClickEvent event) {
                                BusEvenementiel.getInstance().fireEvent(new EvenementVoirDetailsImage(image));
                        }
                });

                vue.getZoom().addClickHandler(new ClickHandler() {
                        public void onClick(ClickEvent event) {
                                FenetreOverlayDefilantePresenteur presenteurGalerie = new FenetreOverlayDefilantePresenteur(0, new FenetreOverlayDefilanteVue()) {
                                        
                                        @Override
                                        public void surClicBoutonSuivant() {
                                        }
                                        
                                        @Override
                                        public void surClicBoutonPrecedent() {
                                        }
                                };
                                presenteurGalerie.ouvrirFenetreModaleDefilante(0, new DetailImagePresenteur(image, new DetailImageVue()));
                                presenteurGalerie.afficherBoutonsSuivantsPrecedents(false);
                        }
                });

                BusEvenementiel.getInstance().addHandler(EvenementVoirDetailsImage.TYPE, new GestionnaireEvenementVoirDetailsImage() {

                        @Override
                        public void onVoirDetailsImage(EvenementVoirDetailsImage event) {
                                if (image.getIdImage().equals(event.getImage().getIdImage())) {

                                        if (!detailsOpen) {
                                                afficherDetails();
                                        } else {
                                                cacherDetails();
                                        }
                                } else {
                                        cacherDetails();
                                }
                        }
                });

                BusEvenementiel.getInstance().addHandler(EvenementChangementProtocole.TYPE, new GestionnaireEvenementChangementProtocole() {

                        @Override
                        public void onChangementProtocole(EvenementChangementProtocole event) {
                                setProtocole(event.getProtocole());
                                loadValidationData();
                        }
                });
        }

        public void cacherDetails() {
                vue.cacherZoneCache();
                detailsOpen = false;
        }

        public void afficherDetails() {
                vue.afficherZoneCache();
                detailsOpen = true;
        }

        public boolean isDetailsOpen() {
                return detailsOpen;
        }

        public Protocole getProtocole() {
                return protocole;
        }

        public void setProtocole(Protocole protocole) {
                this.protocole = protocole;
        }

}