EDIT

/**

* Copyright (C) 2017 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.ui.combo.term;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.Comparator;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.eclipse.jface.util.PropertyChangeEvent;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.widgets.Listener;

import eu.etaxonomy.cdm.model.term.DefinedTermBase;

import eu.etaxonomy.cdm.model.term.TermType;

import eu.etaxonomy.cdm.model.term.TermVocabulary;

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

import eu.etaxonomy.taxeditor.model.DefaultTermComparator;

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.preference.IPreferenceKeys;

import eu.etaxonomy.taxeditor.preference.PreferencesUtil;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.store.TermManager;

import eu.etaxonomy.taxeditor.ui.combo.AbstractComboElement;

import eu.etaxonomy.taxeditor.ui.element.CdmFormFactory;

import eu.etaxonomy.taxeditor.ui.element.CdmPropertyChangeEvent;

import eu.etaxonomy.taxeditor.ui.element.ICdmFormElement;

/**

 * @author n.hoffmann

 * @created Nov 5, 2009

 */

public class TermComboElement<T extends DefinedTermBase>

		extends AbstractComboElement<T> {

	private T emptyElement;

	private static String EMPTY_ELEMENT_LABEL = "";

	private ArrayList<T> terms;

	public List<T> getTerms() {

        return terms;

    }

    private Comparator<T> termComparator;

	public Comparator<T> getTermComparator() {

		return termComparator;

	}

	public void setTermComparator(Comparator<T> termComparator) {

		this.termComparator = termComparator;

		populateTerms();

	}

	private final TermType termType;

	@SuppressWarnings("rawtypes")

    private final TermVocabulary termVocabulary;

	private final Class<T> termClass;

	private List<T> customPreferredTerms;

	private boolean useAbbrevLabel = false;

	private boolean addEmptyElement;

	public TermComboElement(CdmFormFactory formFactory,

			ICdmFormElement parentElement, TermType termType, String labelString, T selection, boolean addEmptyElement,

			int style, boolean useAbbrevLabel, Comparator<T> comparator) {

		this(formFactory, parentElement, null, termType, null, null, labelString, selection, addEmptyElement, style, useAbbrevLabel, comparator);

	}

	public TermComboElement(CdmFormFactory formFactory,

            ICdmFormElement parentElement, TermType termType, String labelString, TermDto selection, boolean addEmptyElement,

            int style, boolean useAbbrevLabel, Comparator<T> comparator) {

        this(formFactory, parentElement, null, termType, null, null, labelString, selection, addEmptyElement, style, useAbbrevLabel, comparator);

    }

	public TermComboElement(CdmFormFactory formFactory,

	        ICdmFormElement parentElement, TermVocabulary<?> termVocabulary, String labelString, T selection, boolean addEmptyElement,

	        int style, boolean useAbbrevLabel, Comparator<T> comparator) {

	    this(formFactory, parentElement, null, null, termVocabulary, null,labelString, selection, addEmptyElement, style, useAbbrevLabel, comparator);

	}

    public TermComboElement(CdmFormFactory formFactory,

            ICdmFormElement parentElement, Class<T> termClass, String labelString, T selection, boolean addEmptyElement,

            int style) {

        this(formFactory, parentElement, termClass, null, null, null, labelString, selection, addEmptyElement, style, false, null);

    }

    public TermComboElement(CdmFormFactory formFactory,

            ICdmFormElement parentElement, Class<T> termClass, String labelString, T selection, boolean addEmptyElement,

            int style, boolean useAbbrevLabel) {

        this(formFactory, parentElement, termClass, null, null, null, labelString, selection, addEmptyElement, style, useAbbrevLabel, null);

    }

    public TermComboElement(CdmFormFactory formFactory,

            ICdmFormElement parentElement, List<T> terms, String labelString, T selection, boolean addEmptyElement,

            int style, boolean useAbbrevLabel, Comparator<T> comparator) {

        this(formFactory, parentElement, null, null, null, terms,labelString, selection, addEmptyElement, style, useAbbrevLabel, comparator);

    }

	private TermComboElement(CdmFormFactory formFactory,

	        ICdmFormElement parentElement, Class<T> termClass, TermType termType, TermVocabulary<?> termVocabulary, List<T> terms,String labelString, T selection, boolean addEmptyElement,

	        int style, boolean useAbbrevLabel, Comparator<T> comparator) {

	    super(formFactory, parentElement);

        this.termVocabulary = termVocabulary;

        this.termClass = termClass;

        this.addEmptyElement = addEmptyElement;

        this.useAbbrevLabel = useAbbrevLabel;

        this.termComparator = comparator;

        if (labelString != null) {

            label.setText(labelString);

        }

        this.selection = selection;

        if(termType!=null){

            //TODO try to remove generic T and avoid classes to be used

        	addTerms((List<T>) getTermManager().getPreferredTerms(termType));

        }

        else if(termVocabulary!=null){

            addTerms((List<T>) getTermManager().getPreferredTerms(termVocabulary));

        }

        else if(this.termClass!=null){

            addTerms(getPreferredTerms());

        }else if (terms != null){

            addTerms(terms);

        }

        if (termType == null && terms != null && !terms.isEmpty()){

        	this.termType = terms.get(0).getTermType();

        }else{

        	this.termType = termType;

        }

        addContentProposalAdapter();

        combo.addSelectionListener(this);

        combo.addDisposeListener(this);

        if (comparator == null){

            setTermComparator(new DefaultTermComparator<>());

        }else{

        	populateTerms();

        }

        PreferencesUtil.getPreferenceStore().addPropertyChangeListener(this);

        if (selection != null) {

            setSelection(selection);

        }

	}

	protected void addTerms(List<T> preferredTerms) {

		terms = new ArrayList<>();

		Collections.sort(preferredTerms, termComparator);

		if(addEmptyElement){

		    // Add an empty element for when nothing was selected yet

		    combo.add(EMPTY_ELEMENT_LABEL);

		    terms.add(emptyElement);

		}

		for (T term: preferredTerms){

			terms.add(term);

		}

	}

	private TermComboElement(CdmFormFactory formFactory,

            ICdmFormElement parentElement, Class<T> termClass, TermType termType, TermVocabulary<?> termVocabulary, List<T> terms,String labelString, TermDto selection, boolean addEmptyElement,

            int style, boolean useAbbrevLabel, Comparator<T> comparator) {

        super(formFactory, parentElement);

        this.termVocabulary = termVocabulary;

        this.termClass = termClass;

        this.addEmptyElement = addEmptyElement;

        this.useAbbrevLabel = useAbbrevLabel;

        this.termComparator = comparator;

        if (labelString != null) {

            label.setText(labelString);

        }

        if(termType!=null){

            //TODO try to remove generic T and avoid classes to be used

            addTerms((List<T>) getTermManager().getPreferredTerms(termType));

        }

        else if(termVocabulary!=null){

            addTerms((List<T>) getTermManager().getPreferredTerms(termVocabulary));

        }

        else if(this.termClass!=null){

            addTerms(getPreferredTerms());

        }else if (terms != null && !terms.isEmpty()){

            addTerms(terms);

        }

        if (termType == null){

        	this.termType = terms.get(0).getTermType();

        }else{

        	this.termType = termType;

        }

        addContentProposalAdapter();

        combo.addSelectionListener(this);

        combo.addDisposeListener(this);

        if (comparator == null){

            setTermComparator(new DefaultTermComparator<T>());

        }else{

        	populateTerms();

        }

        PreferencesUtil.getPreferenceStore().addPropertyChangeListener(this);

        if (this.terms != null && selection != null){

            for (T term: this.terms){

                if (term != null && term.getUuid().equals(selection.getUuid())){

                    this.selection = term;

                }

            }

        }

        if (this.selection != null) {

            setSelection(this.selection);

        }

    }

	/**

	 * <p>Sets the selection of the combo to the given T object.</p>

	 * <p>Passing <code>null</code> to this method will set the selection to

	 * the empty element and effectively clear the selection</p>

	 *

	 * @param selection

	 *            a T object or <code>null</code> to clear the selection

	 */

	@Override

    public void setSelection(T selection) {

		this.selection = selection;

		Listener[] listeners = combo.getListeners(SWT.Selection);

		for (Listener listener : listeners) {

			combo.removeListener(SWT.Selection, listener);

		}

		int selectedIndex;

		if(selection == null){

			// set selection to the emptyElement

			selectedIndex = 0;

		}else{

			selectedIndex = terms.indexOf(selection);

			if (selectedIndex == -1) {

				createTermNotInPreferredTerms(selection, this.terms);

				selectedIndex = terms.indexOf(selection);

			}

		}

		for (Listener listener : listeners) {

			combo.addListener(SWT.Selection, listener);

		}

		combo.select(selectedIndex);

	}

	public void setSelectionDto(TermDto selection) {

        int selectedIndex = 0;

        if(selection == null){

            // set selection to the emptyElement

            selectedIndex = 0;

        }else{

            for (T term: terms){

                if (term != null && term.getUuid().equals(selection.getUuid())){

                    selectedIndex = terms.indexOf(term);

                }

            }

        }

        if (selectedIndex > -1) {

            combo.select(selectedIndex);

        }

    }

	/**

	 * Fills the combo with elements and sets up the convenience functions

	 * for selection index

	 *

	 * @param preferredTerms

	 */

	protected void populateTerms() {

		combo.removeAll();

		int i = 1;

		int index = 0;

		if(addEmptyElement){

		    // Add an empty element for when nothing was selected yet

		    combo.add(EMPTY_ELEMENT_LABEL);

		}

		List<T> withoutNull = new ArrayList<>(terms);

		if (termComparator != null) {

			if (addEmptyElement){

				withoutNull = terms.subList(1, terms.size());

			}

		}

		for (T term : withoutNull) {

			String label = getLabel(term);

			if (label == null) {

				if (term.getTitleCache() != null) {

					label = term.getTitleCache();

					MessagingUtils.warn(getClass(),

							"Term does not have a default language representation: " + label

									+ ", " + term.getUuid());

				} else {

					label = "Unknown";

					MessagingUtils.warn(getClass(),

							"Representation Label and TitleCache empty for term: "

									+ term + ", " + term.getUuid());

				}

			}

			combo.add(label);

			combo.setData(label, term);

			i++;

			if (selection != null) {

				if (selection.equals(term)) {

					index = i;

				}

			}

		}

        if (selection != null && index == 0) {

			createTermNotInPreferredTerms(selection, terms);

		}

		combo.select(index);

	}

	protected List<T> getPreferredTerms(){

	    List<T> preferredTerms = new ArrayList<>();

		if (customPreferredTerms != null){

			return customPreferredTerms;

		}

		else if(termType!=null){

		    preferredTerms = getTermManager().getPreferredTerms(termType);

		}

		else if(termVocabulary!=null){

		    preferredTerms = getTermManager().getPreferredTerms(termVocabulary);

		}

		if(termClass!=null){

		    preferredTerms = getTermManager().getPreferredTerms(termClass);

		}

		return preferredTerms;

	}

	/**

	 * May be overridden by derived classes if the desired label string does not

	 * reside in term.getLabel();

	 *

	 * @param term

	 *            a T object.

	 * @return a {@link java.lang.String} object.

	 */

	protected String getLabel(T term) {

		if (term == null){

			return "";

		}else{

			String termLabel = null;

			if (useAbbrevLabel){

			    if (!StringUtils.isBlank(term.getIdInVocabulary())){

			        termLabel = term.getIdInVocabulary();

			    }

			}

			if (termLabel == null){

				termLabel = term.getLabel(CdmStore.getDefaultLanguage());

			}

			if (termLabel == null){

			    termLabel = term.getLabel();

			}

			if(PreferencesUtil.getBooleanValue(IPreferenceKeys.SHOW_VOCABULARY_ID_FOR_TERM_LABELS)

			    && term.getVocabulary()!=null){

			    String vocLabel = term.getVocabulary().getLabel(CdmStore.getDefaultLanguage());

			    if (vocLabel == null){

			        vocLabel = term.getVocabulary().getLabel();

			    }

			    termLabel += " ["+vocLabel+"]";

			}

            return termLabel;

		}

	}

	private void createTermNotInPreferredTerms(T term, List<T> preferredTerms) {

		terms.add(term);

		populateTerms();

	}

	@Override

    public void widgetSelected(SelectionEvent e) {

	    if (e.getSource().equals(combo) && combo.getSelectionIndex() >= 0){

	    	int index = combo.getSelectionIndex();

	        selection = terms.get(combo.getSelectionIndex());

	        firePropertyChangeEvent(new CdmPropertyChangeEvent(this, e));

	    }

	}

	@Override

    public void propertyChange(PropertyChangeEvent event) {

		super.propertyChange(event);

		T selection = this.selection;

		if (event != null

				&& PreferencesUtil.PREFERRED_TERMS_CHANGE.equals(event

						.getProperty())) {

			addTerms(getPreferredTerms());

			populateTerms();

		}

		this.setSelection(selection);

	}

	protected TermManager getTermManager() {

		return CdmStore.getTermManager();

	}

	public int getVisibleItemCount(){

		return combo.getVisibleItemCount();

	}

	/**

	 * <p>A {@link List} of term objects may be passed to this combo box. In this case, the default behaviour

	 * of displaying the preferred terms for the T type will be overridden and the combo will only display the

	 * given terms. Also, any previous selection will be reseted.</p>

	 *

	 * <p>To return to the default of displaying the preferred terms, simply pass <code>null</code>.</p>

	 *

	 * @param terms a {@link List} of T objects or <code>null</code> for default preferred terms

	 */

	public void setTerms(List<T> terms) {

		customPreferredTerms = terms;

		addTerms(customPreferredTerms);

		populateTerms();

	}

	public void removeEmptyElement(){

	    if(addEmptyElement){

	        if(terms.contains(emptyElement)){

	            terms.remove(emptyElement);

	        }

	        if(Arrays.asList(combo.getItems()).contains(EMPTY_ELEMENT_LABEL)){

	            combo.remove(EMPTY_ELEMENT_LABEL);

	        }

	    }

	}

}