EDIT

/**

 * Copyright (C) 2007 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;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.Comparator;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map.Entry;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.widgets.Combo;

import org.eclipse.ui.forms.widgets.TableWrapData;

import eu.etaxonomy.cdm.model.media.ExternalLinkType;

import eu.etaxonomy.cdm.model.name.NameRelationship;

import eu.etaxonomy.cdm.model.name.NomenclaturalCode;

import eu.etaxonomy.cdm.model.name.NomenclaturalCodeEdition;

import eu.etaxonomy.cdm.model.name.TaxonName;

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

import eu.etaxonomy.cdm.model.reference.OriginalSourceType;

import eu.etaxonomy.cdm.model.reference.ReferenceType;

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

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

import eu.etaxonomy.taxeditor.model.AbstractUtility;

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

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

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

import eu.etaxonomy.taxeditor.ui.section.name.NameRelationshipDetailElement;

import eu.etaxonomy.taxeditor.ui.section.name.NomenclaturalStatusElement;

import eu.etaxonomy.taxeditor.ui.section.name.NomenclaturalStatusSection;

/**

 * @author n.hoffmann

 * @created Mar 16, 2010

 */

public class EnumComboElement<T extends IEnumTerm<T>> extends

		AbstractComboElement<T>  {

	//TODO RL

	public void setVisible(boolean b){

		combo.setVisible(b);

	}

	 private  static  CdmEnumDataHolder[] cdmEnumDataHolders = {

		new CdmEnumDataHolder<NomenclaturalCode>(){

			@Override

			public String getName() {

				return "Nomenclatural Code";

			}

			@Override

			public Collection<NomenclaturalCode> getElements() {

				Collection<NomenclaturalCode> result = new ArrayList<>(Arrays.asList(NomenclaturalCode.values()));

            	result.remove(NomenclaturalCode.ICVCN);

                return  result;

			}

			@Override

			public Class<NomenclaturalCode> getClazz() {

				return NomenclaturalCode.class;

			}

		},

		new CdmEnumDataHolder<ReferenceType>(){

			@Override

			public String getName() {

				return "Reference Type";

			}

			@Override

			public Collection<ReferenceType> getElements() {

				return Arrays.asList(ReferenceType.values());

			}

			@Override

			public Class<ReferenceType> getClazz() {

				return ReferenceType.class;

			}

		},

		new CdmEnumDataHolder<SpecimenOrObservationType>(){

			@Override

			public String getName() {

				return "Specimen / Observation Type";

			}

			@Override

			public Collection<SpecimenOrObservationType> getElements() {

				return Arrays.asList(SpecimenOrObservationType.values());

			}

			@Override

			public Class<SpecimenOrObservationType> getClazz() {

				return SpecimenOrObservationType.class;

			}

		},

		new CdmEnumDataHolder<ExternalLinkType>(){

            @Override

            public String getName() {

                return "Type";

            }

            @Override

            public Collection<ExternalLinkType> getElements() {

                return Arrays.asList(ExternalLinkType.values());

            }

            @Override

            public Class<ExternalLinkType> getClazz() {

                return ExternalLinkType.class;

            }

        },

		new CdmEnumDataHolder<OriginalSourceType>(){

			@Override

			public String getName() {

				return "Original Source Type";

			}

			@Override

			public Collection<OriginalSourceType> getElements() {

				return Arrays.asList(OriginalSourceType.values());

			}

			@Override

			public Class<OriginalSourceType> getClazz() {

				return OriginalSourceType.class;

			}

		},

        new CdmEnumDataHolder<NomenclaturalCodeEdition>(){

            @Override

            public String getName() {

                return "Nomenclatural Code Edition";

            }

            @Override

            public Collection<NomenclaturalCodeEdition> getElements() {

                return Arrays.asList(NomenclaturalCodeEdition.values());

            }

            @Override

            public Class<NomenclaturalCodeEdition> getClazz() {

                return NomenclaturalCodeEdition.class;

            }

        },

		new CdmEnumDataHolder<TaxonNodeStatus>(){

            @Override

            public String getName() {

                return "Taxon Node Status";

            }

            @Override

            public Collection<TaxonNodeStatus> getElements() {

                return Arrays.asList(TaxonNodeStatus.values());

            }

            @Override

            public Class<TaxonNodeStatus> getClazz() {

                return TaxonNodeStatus.class;

            }

        }

	};

	protected List<T> elementTypeList = new ArrayList<>();

	private final Class<T> enumType;

	public EnumComboElement(CdmFormFactory formFactory,

			ICdmFormElement parentElement, Class<T> enumType, Comparator<T> comparator, int style, boolean hasNullValue) {

		super(formFactory, parentElement, hasNullValue);

		this.enumType = enumType;

		label.setText(getDefaultLabelString());

		populateTypes(comparator);

		combo.addSelectionListener(this);

		addContentProposalAdapter();

	}

	public void setIndent(int indent) {

    	TableWrapData layoutData = new TableWrapData();

        layoutData.indent = indent;

        label.setLayoutData(layoutData);

        getLayoutComposite().layout();

	}

	public Combo getCombo(){

	    return combo;

	}

	private String getDefaultLabelString() {

		if(enumType.equals(ReferenceType.class)){

			return "Reference Type";

		} else if (enumType.equals(NomenclaturalCode.class)){

			return "Nomenclatural Code";

		} else if(enumType.equals(OriginalSourceType.class)) {

			return "Orig. Source Type";

		} else if(enumType.equals(SpecimenOrObservationType.class)) {

			return "Spec./Obs. Type";

		} else if(enumType.equals(ExternalLinkType.class)) {

            return "Type";

        } else if(enumType.equals(NomenclaturalCodeEdition.class)) {

            return "Code Edition";

        }else if(enumType.equals(TaxonNodeStatus.class)) {

            return "Placement status";

        }

		return "No Label";

	}

    private void populateTypes(Comparator<T> comparator){

        List<T> elementsForClass = new ArrayList<T>(getElementsForClass(enumType));

        if(comparator!=null){

            Collections.sort(elementsForClass, comparator);

        }

        int index = 0;

        if (hasNullValue){

            combo.add("", index);

            index++;

        }

        // special hierarchical order for specimens

        if(enumType.equals(SpecimenOrObservationType.class)){

            LinkedHashMap<T, String> orderedTerms = AbstractUtility.orderTerms(elementsForClass);

            for(Entry<T, String> keyLabelPair : orderedTerms.entrySet()){

                elementTypeList.add(keyLabelPair.getKey());

                combo.add(keyLabelPair.getValue(), index);

                index++;

            }

        }else if(enumType.equals(NomenclaturalCodeEdition.class)){

            NomenclaturalCode code = null;

            ICdmFormElement parentElement = getParentElement();

            if (parentElement instanceof NameRelationshipDetailElement){

                NameRelationship rel = ((NameRelationshipDetailElement)parentElement).getEntity();

                code = rel.getToName().getNomenclaturalCode();

            }else if (parentElement instanceof NomenclaturalStatusElement){

                ICdmFormElement parent = ((NomenclaturalStatusElement)parentElement).getParentElement();

                TaxonName name = ((NomenclaturalStatusSection)parent).getEntity();

                code = name.getNomenclaturalCode();

            }

            List<NomenclaturalCodeEdition> elements = NomenclaturalCodeEdition.forCode(code);

            LinkedHashMap<NomenclaturalCodeEdition, String> orderedTerms = AbstractUtility.orderTerms(elements);

            for (NomenclaturalCodeEdition codeEdition: elements){

                    elementTypeList.add((T)codeEdition);

                    combo.add(codeEdition.getMessage(), index);

                    index++;

            }

        }

        // default order

        else{

            for(T enumElement : elementsForClass){

                elementTypeList.add(enumElement);

                if (enumElement instanceof IEnumTerm)  {

                    combo.add(((IEnumTerm) enumElement).getMessage(), index);

                    index++;

                }else{

                    combo.add(((Enum) enumElement).name(), index);

                    index++;

                }

            }

        }

	}

	@Override

    public void setSelection(T selection) {

		this.selection = selection;

		int index = elementTypeList.indexOf(selection);

		if (hasNullValue && selection != null){

		    index++;

		}

		combo.select(index);

	}

	/** {@inheritDoc} */

	@Override

    public void widgetSelected(SelectionEvent e) {

        int index = combo.getSelectionIndex();

        if (index == -2){

            return;

        }

        if (hasNullValue ){

            index--;

        }

        if (index<0){

            selection = null;

        }else{

            selection = elementTypeList.get(index);

        }

		firePropertyChangeEvent(new CdmPropertyChangeEvent(this, e));

	}

	private Collection<T> getElementsForClass(Class<T> clazz){

		CdmEnumDataHolder<T> dataHolder = getCdmEnumDataHolderForClass(clazz);

		if (dataHolder != null) {

			return dataHolder.getElements();

		}

		return null;

	}

	private CdmEnumDataHolder<T> getCdmEnumDataHolderForClass(Class<T> clazz){

		for (CdmEnumDataHolder dataHolder : cdmEnumDataHolders) {

			if (dataHolder.getClazz().equals(clazz)){

				return dataHolder;

			}

		}

		return null;

	}

	private interface CdmEnumDataHolder<T> {

		Class<T> getClazz();

		String getName();

		Collection<T> getElements();

	}

}