EDIT

/**

 *

 */

package eu.etaxonomy.taxeditor.ui.dialog.selection;

import java.util.Collections;

import java.util.Comparator;

import java.util.List;

import java.util.Set;

import java.util.UUID;

import org.eclipse.jface.viewers.ILabelProvider;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.SelectionAdapter;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.events.SelectionListener;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Combo;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Control;

import org.eclipse.swt.widgets.Label;

import org.eclipse.swt.widgets.Shell;

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

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

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

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

import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;

import eu.etaxonomy.taxeditor.newWizard.AbstractNewEntityWizard;

import eu.etaxonomy.taxeditor.preference.PreferencesUtil;

import eu.etaxonomy.taxeditor.store.CdmStore;

/**

 * @author p.ciardelli

 * @version $Id: $

 */

public class TaxonNodeSelectionDialog extends AbstractFilteredCdmResourceSelectionDialog<TaxonNode> implements SelectionListener{

	public static TaxonNode select(Shell shell, //ConversationHolder conversation,

	        String title, Set<UUID> excludeTaxa, TaxonNode node, UUID classificationUUID, boolean allowSelectClassification) {

		TaxonNodeSelectionDialog dialog = new TaxonNodeSelectionDialog(shell,

				//conversation,

				title,

				excludeTaxa,

				false,

				node,

				classificationUUID, allowSelectClassification);

		return getSelectionFromDialog(dialog);

	}

	public static TaxonNode select(Shell shell, //ConversationHolder conversation,

            String title, Set<UUID> excludeTaxa, TaxonNode node, UUID classificationUUID) {

        TaxonNodeSelectionDialog dialog = new TaxonNodeSelectionDialog(shell,

                //conversation,

                title,

                excludeTaxa,

                false,

                node,

                classificationUUID);

        return getSelectionFromDialog(dialog);

    }

	public static UuidAndTitleCache<TaxonNode> selectUuidAndTitleCache(Shell shell, //ConversationHolder conversation,

            String title, Set<UUID> excludeTaxa, TaxonNode node, UUID classificationUUID) {

        TaxonNodeSelectionDialog dialog = new TaxonNodeSelectionDialog(shell,

                //conversation,

                title,

                excludeTaxa,

                false,

                node,

                classificationUUID, false);

        return getUuidAndTitleCacheSelectionFromDialog(dialog);

    }

	private Combo classificationSelectionCombo;

	private List<Classification> classifications;

	private Classification selectedClassification;

	private UUID selectedUuid;

//	private final Set<UUID> excludeTaxa;

	private boolean allowClassificationSelection = false;

	protected TaxonNodeSelectionDialog(Shell shell, //ConversationHolder conversation,

	        String title, Set<UUID> excludeTaxa, boolean multi, TaxonNode node, UUID classificationUUID, boolean allowSelectClassification) {

		super(shell, //conversation,

		        title, multi, TaxonNodeSelectionDialog.class.getCanonicalName(), node);

		ILabelProvider labelProvider = new FilteredCdmResourceLabelProvider();

		setListLabelProvider(labelProvider);

//		setDetailsLabelProvider(labelProvider);

		this.cdmBaseToBeFiltered = excludeTaxa;

		if(classificationUUID != null){

            selectedUuid = classificationUUID;

        }

		fillClassifications();

		this.allowClassificationSelection = allowSelectClassification;

		createClassificationSelectionCombo(shell);

	}

	protected TaxonNodeSelectionDialog(Shell shell, //ConversationHolder conversation,

            String title, Set<UUID> excludeTaxa, boolean multi, TaxonNode node, UUID classificationUUID) {

	    this(shell, title, excludeTaxa, multi, node, classificationUUID, false);

	}

	/** {@inheritDoc} */

	@Override

	protected Control createDialogArea(Composite parent) {

	    Composite container = (Composite) super.createDialogArea(parent);

		return createClassificationSelectionCombo(container);

	}

	/*

	 * currently disabled tree selection composite

	 */

	private Control createClassificationSelectionCombo(Composite parent){

//		classifications = CdmStore.getTaxonTreeService().list(null, null, null, null, null);

		Composite classificationSelection = new Composite(parent, SWT.NULL);

		classificationSelection.setLayoutData(new GridData(SWT.FILL, SWT.TOP, true, false));

		GridLayout layout = new GridLayout();

		classificationSelection.setLayout(layout);

		Label label = new Label(classificationSelection, SWT.NULL);

		// TODO not working is not really true but leave it here to remind everyone that this is under construction

		label.setText("Select Classification");

		classificationSelectionCombo = new Combo(classificationSelection, SWT.BORDER | SWT.READ_ONLY);

		classificationSelectionCombo.setLayoutData(new GridData(SWT.FILL, SWT.TOP, true, true));

		for(Classification tree : classifications){

			classificationSelectionCombo.add(tree.getName().getText(), classifications.indexOf(tree));

			if (tree.getUuid().equals(selectedUuid)){

			    selectedClassification = tree;

			}

		}

		classificationSelectionCombo.select(classifications.indexOf(selectedClassification));

		// TODO remember last selection

		classificationSelectionCombo.addSelectionListener(this);

		return classificationSelection;

	}

	/** {@inheritDoc} */

	@Override

	protected String getTitle(TaxonNode taxonNode) {

		if(taxonNode != null && taxonNode.getTaxon() != null){

			return taxonNode.getTaxon().getTitleCache();

		}

		return "";

	}

	@Override

    protected SelectionListener getNewWizardButtonSelectionListener(){

        return new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

                Classification tree = selectedClassification;

                setPattern(tree.getRootNode());

            }

        };

    }

	/** {@inheritDoc} */

	@Override

	protected TaxonNode getPersistentObject(UUID uuid) {

		return CdmStore.getService(ITaxonNodeService.class).find(uuid);

	}

	/** {@inheritDoc} */

	@Override

	protected void callService(String pattern) {

	    model = CdmStore.getService(IClassificationService.class)

	    		.getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(

	    				selectedClassification.getUuid(), limitOfInitialElements, pattern, allowClassificationSelection);

	}

	@Override

	protected void sort() {

	    if(!PreferencesUtil.isSortTaxaByRankAndName()){

            Collections.sort(model, getItemsComparator());

        }

      // otherwise result is already sorted

    }

    private void fillClassifications() {

        if(classifications == null){

			classifications = CdmStore.getService(IClassificationService.class).list(null, null, null, null, null);

			Collections.sort(classifications, new Comparator<Classification>() {

                @Override

                public int compare(Classification o1, Classification o2) {

                    if (o1.equals(o2)){

                        return 0;

                    }

                    int result = o1.getTitleCache().compareTo(o2.getTitleCache());

                    if (result == 0){

                        return o1.getUuid().compareTo(o2.getUuid());

                    }

                    return result;

                }

            });

			if (selectedClassification == null){

//			    if (this.cdmBaseToBeFiltered.isEmpty()){

			        selectedClassification = classifications.iterator().next();

//			    } else {

//			        selectedClassification = this.cdmBaseToBeFiltered.getClassification();

//			    }

			}

		}

    }

	/** {@inheritDoc} */

	@Override

	protected AbstractNewEntityWizard getNewEntityWizard(String parameter) {

		return null;

	}

	/** {@inheritDoc} */

	@Override

	protected String[] getNewWizardText() {

		return null;

	}

	/** {@inheritDoc} */

	@Override

    public void widgetSelected(SelectionEvent e) {

		selectedClassification = classifications.get(classificationSelectionCombo.getSelectionIndex());

//		refresh();

		if (getSearchField().getText() != null){

		    search();

		}

	}

	/** {@inheritDoc} */

	@Override

    public void widgetDefaultSelected(SelectionEvent e) {}

}