Subversion Repositories eFlore/Applications.del

package org.tela_botanica.del.client.vues.pictoflora.moteur;

import java.util.List;

import javax.validation.Configuration;

import org.tela_botanica.del.client.cache.CacheClient;
import org.tela_botanica.del.client.composants.moteurrecherche.MoteurRecherchePresenteur;
import org.tela_botanica.del.client.composants.moteurrecherche.MoteurRechercheVue;
import org.tela_botanica.del.client.composants.partageurl.PartageUrlPresenteur;
import org.tela_botanica.del.client.composants.partageurl.PartageUrlVue;
import org.tela_botanica.del.client.config.Config;
import org.tela_botanica.del.client.modeles.ModeRecherche;
import org.tela_botanica.del.client.modeles.Protocole;
import org.tela_botanica.del.client.modeles.ProtocoleServiceResultat;
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.services.rest.ImageServiceConcret;
import org.tela_botanica.del.client.services.rest.ProtocoleService;
import org.tela_botanica.del.client.services.rest.ProtocoleServiceConcret;
import org.tela_botanica.del.client.services.rest.async.ProtocolesCallback;
import org.tela_botanica.del.client.utils.URLUtils;
import org.tela_botanica.del.client.vues.pictoflora.resultats.ResultatPictofloraPresenteur;
import org.tela_botanica.del.client.vues.pictoflora.resultats.ResultatPictofloraVue;

import com.google.gwt.event.dom.client.ChangeEvent;
import com.google.gwt.event.dom.client.ChangeHandler;
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ClickHandler;
import com.google.gwt.event.dom.client.HasChangeHandlers;
import com.google.gwt.event.dom.client.HasClickHandlers;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.HasWidgets;
import com.google.gwt.user.client.ui.IsWidget;
import com.google.gwt.user.client.ui.ListBox;
import com.google.gwt.user.client.ui.Panel;

public class MoteurPictofloraPresenteur {

        public interface Vue extends IsWidget {
                public HasWidgets getZoneResultats();

                public HasWidgets getZoneRecherche();

                public void ajouterVue(HasWidgets composite);

                public void setListeProtocoles(ListBox listeProtocoles);
                
                public HasChangeHandlers getListeProtocoles();
                
                public void ajouterProtocole(String NomProtocole, String idProtocole);

                public void selectionnerProtocole(int index);
                
                public void selectionnerProtocoleParProtocole(Protocole protocole);
                
                public String getNomProtocoleSelectionne();

                public int getIdProtocoleSelectionne();

                public void ajouterProtocoles(List<Protocole> protocoles);

                public void mettreAJourDescriptionProtocoleCourant(Protocole protocoleCourant);
                
        }

        private Vue vue;
        private ProtocoleService protocoleService;
        private List<Protocole> protocoles;

        /**
         * Constructeur
         * */
        public MoteurPictofloraPresenteur(Vue vue, ProtocoleService protocoleService) {
                
                this.vue = vue;
                this.protocoleService = protocoleService;
                chargerProtocoles();
                
                // TODO: le code ci dessous sert à ne pas recharger les protocoles
                // à chaque fois, voir si on peut le factoriser quelque part
                if (CacheClient.getInstance().getProtocoleCourant() == null) {
                        if (CacheClient.getInstance().getListeProtocoles() == null) {
                                protocoleService.getProtocoles(new ProtocolesCallback() {

                                        @Override
                                        public void surRetour(ProtocoleServiceResultat protocolesRecus) {
                                                CacheClient.getInstance().setListeProtocoles(protocolesRecus.getProtocoles());
                                                if (protocolesRecus.getProtocoles().size() > 0) {
                                                        if(protocoles == null) {
                                                                protocoles = protocolesRecus.getProtocoles();
                                                        }
                                                        //Vérifier qu'on n'a pas demandé un protocole particulier en paramètre
                                                        String parametre = URLUtils.getURLSpecialParameterValue();
                                                        if (parametre != null) {
                                                                for (Protocole protocoleCourant : protocoles) {
                                                                                if (parametre.equals(String.valueOf(protocoleCourant.getId()))) {
                                                                                        CacheClient.getInstance().setProtocoleCourant(protocoleCourant);
                                                                                }
                                                                }
                                                        } else {
                                                                CacheClient.getInstance().setProtocoleCourant(protocolesRecus.getProtocoles().get(0));
                                                        }
                                                } else {
                                                        // TODO afficher message indiquant que la liste des
                                                        // protocoles de votes n'est pas fourni
                                                }
                                        }
                                });
                        } else {
                                CacheClient.getInstance().setProtocoleCourant(CacheClient.getInstance().getListeProtocoles().get(0));
                        }
                }
                gererEvenements();
        }
        
        private void gererEvenements() {
                
                vue.getListeProtocoles().addChangeHandler(new ChangeHandler() {
                        @Override
                        public void onChange(ChangeEvent event) {
                                surChangementProtocole();
                        }
                });
                
        }
        
        private void chargerProtocoles() {
                // test pour ne pas charger les protocoles déjà chargés
                // TODO: faire un systeme de cache gérés par les web service eux même
                if (CacheClient.getInstance().getListeProtocoles() == null) {
                        protocoleService.getProtocoles(new ProtocolesCallback() {

                                @Override
                                public void surRetour(ProtocoleServiceResultat protocolesRecus) {
                                        protocoles = protocolesRecus.getProtocoles();
                                        remplirListeProtocole(protocoles);
                                        surChangementProtocole();
                                }
                        });
                } else {
                        protocoles = CacheClient.getInstance().getListeProtocoles();
                        remplirListeProtocole(CacheClient.getInstance().getListeProtocoles());
                }
        }
        
        public void surChangementProtocole() {
                Protocole protocoleCourant = null;
                for (Protocole protocole : protocoles) {
                        if (protocole.getId() == vue.getIdProtocoleSelectionne()) {
                                protocoleCourant = protocole;
                        }
                }
                vue.mettreAJourDescriptionProtocoleCourant(protocoleCourant);
                CacheClient.getInstance().setProtocoleCourant(protocoleCourant);
                CacheClient.getInstance().mettreAjourUrlCourante();
                EvenementChangementProtocole evenement = new EvenementChangementProtocole(protocoleCourant);
                BusEvenementiel.getInstance().fireEvent(evenement);
        }
        
        private void remplirListeProtocole(List<Protocole> protocoles) {
                //si un paramètre est passé dans l'url, on sélectionne un protocole
                String parametre = URLUtils.getURLSpecialParameterValue();
                if (parametre != null) {
                        for (Protocole protocoleCourant : protocoles) {
                                        if (parametre.equals(String.valueOf(protocoleCourant.getId()))) {
                                                CacheClient.getInstance().mettreAjourUrlCourante();
                                                CacheClient.getInstance().setProtocoleCourant(protocoleCourant);
                                        }
                        }
                }
                vue.ajouterProtocoles(protocoles);
                if (CacheClient.getInstance().getProtocoleCourant() == null) {
                        vue.selectionnerProtocole(0);
                        vue.mettreAJourDescriptionProtocoleCourant(protocoles.get(0));
                } else {
                        vue.selectionnerProtocoleParProtocole(CacheClient.getInstance().getProtocoleCourant());
                        vue.mettreAJourDescriptionProtocoleCourant(CacheClient.getInstance().getProtocoleCourant());
                }
        }

        public void go(HasWidgets composite) {
                vue.ajouterVue(composite);
                chargerMoteurRechercheAvancee();
        }

        public void chargerMoteurRechercheAvancee() {
                MoteurRecherchePresenteur presenteurRecherche = new MoteurRecherchePresenteur(new MoteurRechercheVue(""), ModeRecherche.MODE_IMAGE) {
                        public void lancerRecherche() {
                                chercherImages();
                        }
                };
                presenteurRecherche.go(vue.getZoneRecherche());
        }

        public void chercherImages() {
                vue.getZoneResultats().clear();
                CacheClient.getInstance().mettreAjourUrlCourante();
                new ResultatPictofloraPresenteur(new ImageServiceConcret(), new ProtocoleServiceConcret(), new ResultatPictofloraVue()).go(vue.getZoneResultats());
        }

        public HasWidgets getZoneResultats() {
                return vue.getZoneResultats();
        }
}