EDIT

// $Id$

/**

* Copyright (C) 2013 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.taxeditor.editor.view.derivate.searchFilter;

import java.util.ArrayList;

import java.util.Collection;

import java.util.List;

import java.util.UUID;

import org.eclipse.swt.SWT;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Event;

import org.eclipse.swt.widgets.Listener;

import org.eclipse.swt.widgets.Widget;

import eu.etaxonomy.cdm.api.conversation.ConversationHolder;

import eu.etaxonomy.cdm.api.service.IOccurrenceService;

import eu.etaxonomy.cdm.api.service.config.FindOccurrencesConfigurator;

import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;

import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationType;

import eu.etaxonomy.cdm.model.taxon.Taxon;

import eu.etaxonomy.cdm.model.taxon.TaxonBase;

import eu.etaxonomy.taxeditor.editor.view.derivate.DerivateView;

import eu.etaxonomy.taxeditor.editor.view.derivate.DerivateViewEditorInput;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.store.SearchManager;

import eu.etaxonomy.taxeditor.ui.dialog.selection.SelectionDialogFactory;

import eu.etaxonomy.taxeditor.ui.mvc.combo.EnumTermComboController;

import eu.etaxonomy.taxeditor.view.derivateSearch.DerivateLabelProvider;

/**

 * Controller class for the {@link DerivateSearchComposite}.<br>

 * This controller contains the logic to search the data base for {@link SpecimenOrObservationBase}s

 * and handles GUI events.

 *

 */

public class DerivateSearchCompositeController implements Listener{

    private final DerivateSearchComposite derivateSearchComposite;

    private EnumTermComboController<SpecimenOrObservationType> comboSpecimenTypeController;

	private DerivateLabelProvider labelProvider;

	private Taxon selectedTaxon;

    private DerivateView derivativeEditor;

    public DerivateSearchCompositeController(Composite parent, DerivateView derivativeEditor) {

        this.derivateSearchComposite = new DerivateSearchComposite(parent, SWT.NONE);

        this.derivativeEditor = derivativeEditor;

        init();

    }

    private void init(){

        //derivate type combo

        comboSpecimenTypeController = new EnumTermComboController<SpecimenOrObservationType>(derivateSearchComposite.getComboDerivateType(), null, null, SpecimenOrObservationType.class, 0);

        comboSpecimenTypeController.setSelection(SpecimenOrObservationType.Unknown);

        //add listeners

        derivateSearchComposite.getSearchField().addListener(SWT.KeyDown, this);

        derivateSearchComposite.getButtonSearch().addListener(SWT.Selection, this);

        derivateSearchComposite.getBtnBrowseTaxa().addListener(SWT.Selection, this);

        derivateSearchComposite.getBtnClearTaxon().addListener(SWT.Selection, this);

    }

    private void searchDerivates(){

//        if(!conversation.isBound()){

//            conversation.bind();

//        }

        String queryString = derivateSearchComposite.getSearchField().getText();

        SpecimenOrObservationType specimenType = comboSpecimenTypeController.getSelection();

        FindOccurrencesConfigurator config = new FindOccurrencesConfigurator();

        config.setAssociatedTaxonUuid(selectedTaxon!=null?selectedTaxon.getUuid():null);

        config.setSpecimenType(specimenType.equals(SpecimenOrObservationType.Unknown)?null:specimenType);//unknown := all types

        config.setTitleSearchString(queryString);

        if(selectedTaxon!=null){

            config.setRetrieveIndirectlyAssociatedSpecimens(true);

            config.setSpecimenType(null);

        }

        SearchManager searchManager = new SearchManager();

        List<SpecimenOrObservationBase> occurrences = searchManager.findOccurrences(config, true);

        //filter out specimens of wrong type (only if an associated taxon was selected)

        if(selectedTaxon!=null && !specimenType.equals(SpecimenOrObservationType.Unknown)){

            List<SpecimenOrObservationBase> specimensOfCorrectType = new ArrayList<SpecimenOrObservationBase>();

            for(SpecimenOrObservationBase<?> occurrence:occurrences){

                if(occurrence.getRecordBasis().equals(specimenType)

                        || occurrence.getRecordBasis().isKindOf(specimenType)){

                    specimensOfCorrectType.add(occurrence);

                }

            }

            occurrences = specimensOfCorrectType;

        }

        //filter out (un-)assigned specimens

        int selectionIndex = derivateSearchComposite.getComboTaxonAssignment().getSelectionIndex();

        List<SpecimenOrObservationBase> specimensWithAssociations = new ArrayList<SpecimenOrObservationBase>();

        if(selectionIndex!=DerivateSearchComposite.ALL_SPECIMENS){

            for (SpecimenOrObservationBase specimenOrObservationBase : occurrences) {

                Collection<TaxonBase<?>> associatedTaxa = CdmStore.getService(IOccurrenceService.class).listAssociatedTaxa(specimenOrObservationBase, null, null, null, null);

                if(!associatedTaxa.isEmpty()){

                    specimensWithAssociations.add(specimenOrObservationBase);

                }

            }

        }

        if(selectionIndex==DerivateSearchComposite.ASSIGNED_SPECIMENS){

            occurrences = specimensWithAssociations;

        }

        else if(selectionIndex==DerivateSearchComposite.UNASSIGNED_SPECIMENS){

            occurrences.retainAll(specimensWithAssociations);

        }

        List<UUID> derivateUuids = new ArrayList<UUID>();

        for (SpecimenOrObservationBase specimenOrObservationBase : occurrences) {

            derivateUuids.add(specimenOrObservationBase.getUuid());

        }

        //update tree

        DerivateViewEditorInput editorInput = (DerivateViewEditorInput)derivativeEditor.getEditorInput();

        editorInput.updateRootEntities(derivateUuids);

        derivativeEditor.getViewer().setInput(editorInput.getRootEntities());

        derivativeEditor.refreshTree();

    }

    @Override

    public void handleEvent(Event event) {

        Widget eventSource = event.widget;

        if(eventSource == derivateSearchComposite.getButtonSearch()

                || (eventSource == derivateSearchComposite.getSearchField() && event.keyCode == SWT.CR)){

            searchDerivates();

        }

        else if(eventSource==derivateSearchComposite.getBtnBrowseTaxa()){

            selectedTaxon = SelectionDialogFactory.getSelectionFromDialog(Taxon.class, this.derivateSearchComposite.getShell(), derivativeEditor.getConversationHolder(), null);

            if(selectedTaxon!=null){

                derivateSearchComposite.getTextTaxonName().setText(selectedTaxon.getTitleCache());

            }

        }

        else if(eventSource==derivateSearchComposite.getBtnClearTaxon()){

            selectedTaxon = null;

            derivateSearchComposite.getTextTaxonName().setText("");

        }

    }

    /**

     * Sets enable status of all input fields

     * @param enabled

     */

    public void setEnabled(boolean enabled) {

        if(!derivateSearchComposite.isDisposed()){

            derivateSearchComposite.setEnabled(enabled);

        }

    }

    public void setLayoutData(Object layoutData){

        derivateSearchComposite.setLayoutData(layoutData);

    }

    /**

     * Resets all input fields

     */

    public void reset(){

        if(!derivateSearchComposite.isDisposed()){

            derivateSearchComposite.getSearchField().setText("");

            derivateSearchComposite.getComboDerivateType().deselectAll();

            comboSpecimenTypeController.setSelection(SpecimenOrObservationType.Unknown);

        }

        selectedTaxon = null;

    }

    public void setConversation(ConversationHolder conversationHolder) {

        labelProvider.setConversation(conversationHolder);

    }

}