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.store;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.UUID;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.ui.IMemento;

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

import eu.etaxonomy.cdm.model.common.TermBase;

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

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

import eu.etaxonomy.taxeditor.model.ContextListenerAdapter;

import eu.etaxonomy.taxeditor.model.TaxonRelationshipTypeInverseContainer;

/**

 * @author n.hoffmann

 * @created Dec 7, 2010

 * @version 1.0

 */

public class TermManager extends ContextListenerAdapter{

	private static final String TERMS = "terms";

	private static final String TERM = "term";

	private static final String HIDE = "hide";

	private static final String CLASS = "class";

	private static final String UUID_STRING = "uuid";

	private final Map<String, Collection<UUID>> hiddenTermsMap = new HashMap<String, Collection<UUID>>();

	public TermManager(){

		CdmStore.getContextManager().addContextListener(this);

	}

	/**

	 *

	 * @param clazz

	 * @return

	 */

	public <T extends DefinedTermBase> List<T> getPreferredTerms(TermType termType){

	    return getFilteredTerms(TermStore.<T>getTerms(termType, null));

	}

	/**

	 *

	 * @param clazz

	 * @return

	 */

	public <T extends DefinedTermBase> List<T> getPreferredTerms(TermVocabulary<T> termVocabulary){

	    return getFilteredTerms(new ArrayList<T>(TermStore.getTerms(termVocabulary, null)));

	}

	/**

	 *

	 * @param clazz

	 * @return

	 */

	public <T extends DefinedTermBase> List<T> getPreferredTerms(Class<T> clazz){

		return getFilteredTerms(TermStore.getTerms(clazz));

	}

	@Override

	public void contextStart(IMemento memento, IProgressMonitor monitor) {

		// read preferred terms from memento into an in memory representation

		if(memento == null){

			return;

		}

		IMemento terms = memento.getChild(TERMS);

		if(terms == null){

			return;

		}

		for(IMemento term : terms.getChildren(TERM)){

			String typeName = term.getString(CLASS);

			Collection<UUID> hiddenTermUuids = new ArrayList<UUID>();

			for(IMemento hide : term.getChildren(HIDE)){

				String uuidString = hide.getString(UUID_STRING);

				UUID uuid = UUID.fromString(uuidString);

				hiddenTermUuids.add(uuid);

			}

			hiddenTermsMap.put(typeName, hiddenTermUuids);

		}

	}

	@Override

	public void contextStop(IMemento memento, IProgressMonitor monitor) {

		saveTerms(memento, monitor);

	}

	@Override

	public void workbenchShutdown(IMemento memento, IProgressMonitor monitor) {

		saveTerms(memento, monitor);

	}

	private void saveTerms(IMemento memento, IProgressMonitor monitor){

		if(memento == null) {

            return;

        }

		IMemento terms = memento.createChild(TERMS);

		for (String preferredTerm : hiddenTermsMap.keySet()){

			IMemento term = terms.createChild(TERM);

			term.putString(CLASS, preferredTerm);

			for(UUID uuid : hiddenTermsMap.get(preferredTerm)){

				IMemento hide = term.createChild(HIDE);

				hide.putString(UUID_STRING, uuid.toString());

			}

		}

	}

	/**

	 * Generic method to get term preferences for a term vocabulary

	 *

	 * @param initialTerms a {@link java.util.List} object.

	 * @return a {@link java.util.List} object.

	 */

	public <T extends DefinedTermBase> List<T> getFilteredTerms(List<T> initialTerms){

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

		String typeName = getTermClass(initialTerms);

		Collection<UUID> hiddenTermUuids = hiddenTermsMap.get(typeName);

		if(hiddenTermUuids == null){

			return initialTerms;

		}

		for (T term : initialTerms){

			if (term instanceof TaxonRelationshipTypeInverseContainer){

				if(! hiddenTermUuids.contains(((TaxonRelationshipTypeInverseContainer) term).getType().getUuid())){

					T type = (T)((TaxonRelationshipTypeInverseContainer) term).getType();

					filteredTerms.add(type);

				}

			}

			if(! hiddenTermUuids.contains(term.getUuid())){

				filteredTerms.add(term);

			}

		}

		return filteredTerms;

	}

	private <T extends DefinedTermBase> String getTermClass(Collection<T> initialTerms){

		String result = null;

		if(!initialTerms.isEmpty()){

			//TODO: there should be a more generic solution!!

	    	T entity = initialTerms.iterator().next();

	    	if (entity instanceof TaxonRelationshipTypeInverseContainer){

	    		result = ((TaxonRelationshipTypeInverseContainer) entity).getType().getClass().getName();

	    	} else {

	    		result = entity.getClass().getName();

	    	}

	        return result;

	    }

	    return null;

	}

//	/**

//	 * <p>getPreferredSpecimenTypeDesignationStatus</p>

//	 *

//	 * @return a {@link java.util.List} object.

//	 */

//	public List<SpecimenTypeDesignationStatus> getPreferredSpecimenTypeDesignationStatus() { return getFilteredTerms(TermStore.getSpecimenTypeDesignationStatus());}

//

//	/**

//	 * <p>getPreferredNameTypeDesignationStatus</p>

//	 *

//	 * @return a {@link java.util.List} object.

//	 */

//	public List<NameTypeDesignationStatus> getPreferredNameTypeDesignationStatus() { return getFilteredTerms(TermStore.getNameTypeDesignationStatus()); }

//

//	/**

//	 * <p>getPreferredTaxonRelationshipTypes</p>

//	 *

//	 * @return a {@link java.util.List} object.

//	 */

//	public List<TaxonRelationshipType> getPreferredTaxonRelationshipTypes() { return getFilteredTerms(TermStore.getTaxonRelationshipTypes());}

//

//	private static List<TaxonRelationshipType> excludeTaxonRelationshipTypes = Arrays.asList(new TaxonRelationshipType[]{

//			TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(),

//			TaxonRelationshipType.MISAPPLIED_NAME_FOR(),

//			TaxonRelationshipType.ALL_RELATIONSHIPS()

//	});

//

//	/**

//	 * Please note that the {@link TaxonRelationshipType}s TAXONOMICALLY_INCLUDED_IN, MISAPPLIED_NAME_FOR and ALL_RELATIONSHIPS

//	 * are filtered out as they are most likely not needed. If you do need them please refactor this method to your needs.

//	 *

//	 * @return a list of {@link TaxonRelationshipTypeInverseContainer} elements

//	 */

//	public List<TaxonRelationshipTypeInverseContainer> getPreferredRelationshipTypesWithInverses(){

//		List<TaxonRelationshipTypeInverseContainer> relationshipTypeInverseContainers = new ArrayList<TaxonRelationshipTypeInverseContainer>();

//

//		List<TaxonRelationshipType> relationshipTypes = getPreferredTaxonRelationshipTypes();

//

//		relationshipTypes.removeAll(excludeTaxonRelationshipTypes);

//

//		for (TaxonRelationshipType relationshipType : relationshipTypes){

//			if(!relationshipType.isSymmetric()){

//				TaxonRelationshipTypeInverseContainer inverseContainer = new TaxonRelationshipTypeInverseContainer(relationshipType, true);

//				relationshipTypeInverseContainers.add(inverseContainer);

//			}

//			TaxonRelationshipTypeInverseContainer container = new TaxonRelationshipTypeInverseContainer(relationshipType, false);

//			relationshipTypeInverseContainers.add(container);

//		}

//

//		return relationshipTypeInverseContainers;

//	}

//

//	/**

//	 * <p>getPreferredFeatures</p>

//	 *

//	 * @return a {@link java.util.List} object.

//	 */

//	public List<Feature> getPreferredFeatures() { return getFilteredTerms(TermStore.getFeatures());}

//

//	/**

//	 * <p>getPreferredRanks</p>

//	 *

//	 * @return a {@link java.util.List} object.

//	 */

//	public List<Rank> getPreferredRanks() { return getFilteredTerms(TermStore.getRanks());}

//

//	/**

//	 * <p>getPreferredPresenceAbsenceTerms</p>

//	 *

//	 * @return a {@link java.util.List} object.

//	 */

//	public List<PresenceAbsenceTermBase> getPreferredPresenceAbsenceTerms(){ return getFilteredTerms(TermStore.getPresenceAbsenceTerms());}

//

//	/**

//	 * <p>getPreferredNomenclaturalStatusTypes</p>

//	 *

//	 * @return a {@link java.util.List} object.

//	 */

//	public List<NomenclaturalStatusType> getPreferredNomenclaturalStatusTypes(){	return getFilteredTerms(TermStore.getNomenclaturalStatusTypes());}

//

//	/**

//	 * <p>getPreferredNameRelationshipTypes</p>

//	 *

//	 * @return a {@link java.util.List} object.

//	 */

//	public List<NameRelationshipType> getPreferredNameRelationshipTypes(){ return getFilteredTerms(TermStore.getNameRelationshipTypes());}

//

//	/**

//	 * <p>getPreferredLanguages</p>

//	 *

//	 * @return a {@link java.util.List} object.

//	 */

//	public List<Language> getPreferredLanguages() { return getFilteredTerms(TermStore.getLanguages()); }

//

//	/**

//	 * <p>getPreferredMarkerTypes</p>

//	 *

//	 * @return a {@link java.util.List} object.

//	 */

//	public List<MarkerType> getPreferredMarkerTypes() { return getFilteredTerms(TermStore.getNonTechnicalMarkerTypes()); }

//

//	/**

//	 * <p>getPreferredExtensionTypes</p>

//	 *

//	 * @return a {@link java.util.List} object.

//	 */

//	public List<ExtensionType> getPreferredExtensionTypes() { return getFilteredTerms(TermStore.getExtensionTypes()); }

//

//	/**

//	 * <p>getPreferredRightsTypes</p>

//	 *

//	 * @return a {@link java.util.List} object.

//	 */

//	public List<RightsType> getPreferredRightsTypes() { 	return getFilteredTerms(TermStore.getRightsTypes());}

//

//	/**

//	 * <p>getPreferredNamedAreaTypes</p>

//	 *

//	 * @return a {@link java.util.List} object.

//	 */

//	public List<NamedAreaType> getPreferredNamedAreaTypes() { return getFilteredTerms(TermStore.getNamedAreaTypes()); }

//

//	/**

//	 * <p>getPreferredNamedAreaTypes</p>

//	 *

//	 * @return a {@link java.util.List} object.

//	 */

//	public List<NamedAreaLevel> getPreferredNamedAreaLevels() { return getFilteredTerms(TermStore.getNamedAreaLevels()); }

//

//	/**

//	 * <p>getPreferredAnnotationTypes</p>

//	 *

//	 * @return a {@link java.util.List} object.

//	 */

//	public List<AnnotationType> getPreferredAnnotationTypes() { return getFilteredTerms(TermStore.getAnnotationTypes()); }

//

//	/**

//	 * <p>getPreferredStages</p>

//	 *

//	 * @return a {@link java.util.List} object.

//	 */

//	public List<Stage> getPreferredStages() { return getFilteredTerms(TermStore.getStages()); }

//

//	/**

//	 * <p>getPreferredPreservationMethods</p>

//	 *

//	 * @return a {@link java.util.List} object.

//	 */

//	public List<PreservationMethod> getPreferredPreservationMethods() { return getFilteredTerms(TermStore.getPreservationMethods()); }

//

//	/**

//	 * <p>getPreferredMeasurementUnits</p>

//	 *

//	 * @return a {@link java.util.List} object.

//	 */

//	public List<MeasurementUnit> getPreferredMeasurementUnits() { return getFilteredTerms(TermStore.getMeasurementUnits()); }

//

//	/**

//	 * <p>getPreferredStates</p>

//	 *

//	 * @return a {@link java.util.List} object.

//	 */

//	public List<State> getPreferredStates() { return getFilteredTerms(TermStore.getStates()); }

//

//	/**

//	 * <p>getPreferredModifiers</p>

//	 *

//	 * @return a {@link java.util.List} object.

//	 */

//	public List<Modifier> getPreferredModifiers() { return getFilteredTerms(TermStore.getModifiers()); }

//

//	/**

//	 * <p>getPreferredStatisticalMeasures</p>

//	 *

//	 * @return a {@link java.util.List} object.

//	 */

//	public List<StatisticalMeasure> getPreferredStatisticalMeasures() { return getFilteredTerms(TermStore.getStatisticalMeasures()); }

//

//	/**

//	 * <p>getPreferredScopes</p>

//	 *

//	 * @return a {@link java.util.List} object.

//	 */

//	public List<Scope> getPreferredScopes() { return getFilteredTerms(TermStore.getScopes()); }

//

//	/**

//	 * <p>getPreferredDeterminationModifiers</p>

//	 *

//	 * @return a {@link java.util.List} object.

//	 */

//	public List<DeterminationModifier> getPreferredDeterminationModifiers() { return getFilteredTerms(TermStore.getDeterminationModifiers()); }

//

	/**

	 * Generic method to set term preferences

	 *

	 * @param preferredTerms a {@link java.util.List} object.

	 * @param initialTerms a {@link java.util.List} object.

	 * @param <T> a T object.

	 */

	public <T extends DefinedTermBase> void setPreferredTerms(Collection<T> preferredTerms, Collection<T> initialTerms){

		String typeName = getTermClass(initialTerms);

		Collection<UUID> undesiredTermUuids = new ArrayList<UUID>();

		for(TermBase term : initialTerms){

			if(! preferredTerms.contains(term)){

				undesiredTermUuids.add(term.getUuid());

			}

		}

		hiddenTermsMap.put(typeName, undesiredTermUuids);

	}

}