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

import java.util.Collections;

import java.util.Comparator;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

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

import eu.etaxonomy.cdm.api.service.exception.ReferencedObjectUndeletableException;

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

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

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

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

import eu.etaxonomy.cdm.model.description.Feature;

import eu.etaxonomy.cdm.model.description.PresenceAbsenceTerm;

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

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

import eu.etaxonomy.taxeditor.model.DefaultTermComparator;

import eu.etaxonomy.taxeditor.model.TaxonRelationshipTypeInverseContainer;

import eu.etaxonomy.taxeditor.preference.PreferencesUtil;

/**

 * All terms may be accessed through this store.

 * Note: This is for internal use. When using vocabularies in the UI, try to use the preferred terms from

 * PreferenceUtil

 *

 * @author n.hoffmann

 * @created 25.06.2009

 * @version 1.0

 */

public class TermStore {

	/**

	 * Returns an alphabetically sorted list of terms (anything that extends {@link DefinedTermBase}) of the given type currently available in the system.

	 *

	 * @param clazz a class that inherits from {@link DefinedTermBase}

	 * @return an alphabetically sorted list of terms

	 */

	public static <TERM extends DefinedTermBase> List<TERM> getTerms(Class<TERM> clazz){

		return getTerms(clazz, null, true);

	}

	/**

	 * Returns an alphabetically sorted list of terms (anything that extends {@link DefinedTermBase}) of the given {@link TermType})

	 * currently available in the system.

	 *

	 * @param termType the term type

	 * @return an alphabetically sorted list of terms

	 */

	public static <TERM extends DefinedTermBase> List<TERM> getTerms(TermType termType, Comparator<TERM> comparator){

        return getTermsFromService(termType, comparator);

	}

	/**

	 * Returns an alphabetically sorted list of terms (anything that extends {@link DefinedTermBase}) of the given {@link TermType})

	 * currently available in the system.

	 *

	 * @param termType the term type

	 * @return an alphabetically sorted list of terms

	 */

	public static <TERM extends DefinedTermBase> Set<TERM> getTerms(TermVocabulary<TERM> termVocabulary, Comparator<DefinedTermBase<?>> comparator){

	    return termVocabulary.getTerms();

	}

	/**

	 * Returns a list of terms of the given type currently available in the system.

	 * If <code>filtered</code> is set to <code>true</code>, all terms for certain types will be

	 * gathered from edge cases.

	 *

	 * @param clazz a class that inherits from {@link DefinedTermBase}

	 * @param comparator a {@link Comparator} that defines the sorting algorithm. If set to null, {@link DefaultTermComparator} will be used

	 * @param filtered if set to true, some terms are filtered from the result (according to definition in {@link ITermStoreEdgeCase}s)

	 * @return a sorted list of terms

	 */

	public static <TERM extends DefinedTermBase> List<TERM> getTerms(Class<TERM> clazz, Comparator<TERM> comparator, boolean filtered){

		List<TERM> terms = new ArrayList<TERM>();

		ITermStoreEdgeCase<TERM> edgeCase = getEdgeCase(clazz);

		if(filtered && edgeCase != null){

			terms = edgeCase.getTerms();

		}else{

			terms = getTermsFromService(clazz, comparator);

		}

		return terms;

	}

	/**

	 *

	 * @param termClass

	 * @param comparator

	 * @return

	 */

	private static <T extends DefinedTermBase> List<T> getTermsFromService(TermType termType, Comparator<T> comparator){

	    if (comparator == null){

	        comparator = new DefaultTermComparator<T>();

	    }

	    List<T> terms = CdmStore.getService(ITermService.class).listByTermType(termType, null, null, null, null);

	    Collections.sort(terms, comparator);

	    return terms;

	}

	/**

	 *

	 * @param termClass

	 * @param comparator

	 * @return

	 */

	private static <T extends DefinedTermBase> List<T> getTermsFromService(Class<T> termClass, Comparator<T> comparator){

		if (comparator == null){

			comparator = new DefaultTermComparator<T>();

		}

		List<T> terms = CdmStore.getService(ITermService.class).list(termClass, null, null, null, null);

		Collections.sort(terms, comparator);

		return terms;

	}

	/**

	 * @param term a {@link eu.etaxonomy.cdm.model.common.DefinedTermBase} object.

	 */

	public static void saveTerm(DefinedTermBase term){

		CdmStore.getService(ITermService.class).saveOrUpdate(term);

	}

	/**

	 * <p>delete</p>

	 *

	 * @param selected a {@link eu.etaxonomy.cdm.model.common.DefinedTermBase} object.

	 * @throws ReferencedObjectUndeletableException

	 */

	public static void delete(DefinedTermBase selected) throws ReferencedObjectUndeletableException {

		CdmStore.getService(ITermService.class).delete(selected);

	}

	/**

	 * Save a vacabulary to data store

	 *

	 * @param term a {@link eu.etaxonomy.cdm.model.common.DefinedTermBase} object.

	 */

	public static void updateVocabulary(DefinedTermBase term) {

		CdmStore.getService(ITermService.class).saveOrUpdate(term);

	}

	/**

	 * Handingling of special cases

	 */

	private static Set<ITermStoreEdgeCase<? extends DefinedTermBase>> termStoreEdgeCases = new HashSet<ITermStoreEdgeCase<? extends DefinedTermBase>>();

	static {

		termStoreEdgeCases.add(new ITermStoreEdgeCase<Feature>() {

			@Override

			public Class<Feature> getTermClass() {

				return Feature.class;

			}

			@Override

			public List<Feature> getTerms() {

				List<Feature> features = TermStore.getTermsFromService(Feature.class, null);

				features.remove(Feature.IMAGE());

				return features;

			}

		});

		termStoreEdgeCases.add(new ITermStoreEdgeCase<MarkerType>(){

			@Override

			public Class<MarkerType> getTermClass() {

				return MarkerType.class;

			}

			@Override

			public List<MarkerType> getTerms() {

				// filter out non technical markers

				List<MarkerType> nonTechnicalMarkerTypes = new ArrayList<MarkerType>();

				List<MarkerType> markerTypes = TermStore.getTermsFromService(MarkerType.class, null);

				for (Object type : markerTypes) {

					if (((MarkerType) type).isTechnical() == false) {

						nonTechnicalMarkerTypes.add((MarkerType) type);

					}

				}

				return nonTechnicalMarkerTypes;

			}

		});

		termStoreEdgeCases.add(new ITermStoreEdgeCase<Rank>() {

			@Override

			public Class<Rank> getTermClass() {

				return Rank.class;

			}

			@Override

			public List<Rank> getTerms() {

				if(PreferencesUtil.getSortRanksHierarchichally()){

					return TermStore.getTermsFromService(Rank.class, new Comparator<Rank>(){

						@Override

						public int compare(Rank o1, Rank o2) {

							return o1.compareTo(o2);

						}

					});

				}else{

					return TermStore.getTermsFromService(Rank.class, null);

				}

			}

		});

		termStoreEdgeCases.add(new ITermStoreEdgeCase<PresenceAbsenceTerm>() {

			@Override

			public Class<PresenceAbsenceTerm> getTermClass() {

				return PresenceAbsenceTerm.class;

			}

			@Override

			public List<PresenceAbsenceTerm> getTerms() {

				List<PresenceAbsenceTerm> presenceAbsenceTerms = TermStore.getTermsFromService(PresenceAbsenceTerm.class, null);

				return presenceAbsenceTerms;

			}

		});

		termStoreEdgeCases.add(new ITermStoreEdgeCase<TaxonRelationshipTypeInverseContainer>() {

			@Override

			public Class<TaxonRelationshipTypeInverseContainer> getTermClass() {

				return TaxonRelationshipTypeInverseContainer.class;

			}

			@Override

			public List<TaxonRelationshipTypeInverseContainer> getTerms() {

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

					TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(),

					TaxonRelationshipType.MISAPPLIED_NAME_FOR(),

					TaxonRelationshipType.ALL_RELATIONSHIPS()

				});

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

				List<TaxonRelationshipType> relationshipTypes = TermStore.getTerms(TaxonRelationshipType.class);

				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;

			}

		});

	}

	private static <T extends DefinedTermBase> ITermStoreEdgeCase<T> getEdgeCase(Class<T> termClass) {

		for (ITermStoreEdgeCase termStoreEdgeCase : termStoreEdgeCases){

			if (termStoreEdgeCase.getTermClass().equals(termClass)){

				return termStoreEdgeCase;

			}

		}

		return null;

	}

	private interface ITermStoreEdgeCase<TERM> {

		public abstract Class<TERM> getTermClass();

		public abstract List<TERM> getTerms();

	}

}