EDIT

// $Id$

/**

* 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.model.common.DefinedTermBase;

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

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

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

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

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

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

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

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 {

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

		return getTerms(clazz, null, true);

	}

	/**

	 * 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

	 * @param comparator

	 * @param filtered Will filter out some results

	 * @return

	 */

	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;

	}

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

		if (comparator == null){

			comparator = new Comparator<T>() {

				@Override

				public int compare(T o1, T o2) {

					String label1 = o1.getLabel(CdmStore.getDefaultLanguage()) != null ? o1.getLabel(CdmStore.getDefaultLanguage()) : o1.getTitleCache();

					String label2 = o2.getLabel(CdmStore.getDefaultLanguage()) != null ? o2.getLabel(CdmStore.getDefaultLanguage()) : o2.getTitleCache();

					return label1.compareTo(label2);

				}

			};

		}

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

		Collections.sort(terms, comparator);

		return terms;

	}

//	/**

//	 * <p>getFeatures</p>

//	 *

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

//	 */

//	public static List<Feature> getFeatures() {

//		List<Feature> features = getTerms(Feature.class);

//		features.remove(Feature.IMAGE());

//		return features;

//

//	}

//

//

//	/**

//	 * <p>getNonTechnicalMarkerTypes</p>

//	 *

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

//	 */

//	public static List<MarkerType> getNonTechnicalMarkerTypes() {

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

//		List<MarkerType> markerTypes = getTerms(MarkerType.class);

//		

//		for (Object type : markerTypes) {

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

//				nonTechnicalMarkerTypes.add((MarkerType) type);

//			}

//		}

//		

//		return nonTechnicalMarkerTypes;

//	}

//

//	/**

//	 * Retrieve all ranks from data store.

//	 *

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

//	 */

//	public static List<Rank> getRanks(){

//		if(PreferencesUtil.getSortRanksHierarchichally()){

//			return getTerms(Rank.class, new Comparator<Rank>(){

//	

//				@Override

//				public int compare(Rank o1, Rank o2) {

//					return o1.compareTo(o2);

//				}

//				

//			});

//		}else{

//			return getTerms(Rank.class);

//		}

//	}

//	

//	

//	/**

//	 * Retrieve all presence and absence terms from data store.

//	 *

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

//	 */

//	public static List<PresenceAbsenceTermBase> getPresenceAbsenceTerms() {

//		List presenceAbsenceTerms = getTerms(PresenceTerm.class);

//		presenceAbsenceTerms.addAll(getTerms(AbsenceTerm.class));

//

//		return presenceAbsenceTerms;

//	}

	/**

	 * @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.

	 */

	public static void delete(DefinedTermBase selected) {

		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);

	}

	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<PresenceAbsenceTermBase>() {

			@Override

			public Class<PresenceAbsenceTermBase> getTermClass() {

				return PresenceAbsenceTermBase.class;

			}

			@Override

			public List<PresenceAbsenceTermBase> getTerms() {

				List presenceAbsenceTerms = TermStore.getTermsFromService(PresenceTerm.class, null);

				presenceAbsenceTerms.addAll(TermStore.getTermsFromService(AbsenceTerm.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();

	}

}