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

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.UUID;

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

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

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

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

import eu.etaxonomy.taxeditor.model.DefaultTermComparator;

import eu.etaxonomy.taxeditor.model.TaxonRelationshipTypeInverseContainer;

import eu.etaxonomy.taxeditor.preference.PreferencesUtil;

/**

 * @author n.hoffmann

 * @created Dec 7, 2010

 * @version 1.0

 */

public class TermManager {

	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 Map<Object, List> cachedTermMap = new HashMap<>();

	public TermManager(){

	}

	/**

	 *

	 * @param clazz

	 * @return

	 */

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

	    List terms = cachedTermMap.get(termType);

	    if(terms==null){

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

	        cachedTermMap.put(termType, terms);

	    }

        return terms;

	}

	/**

	 *

	 * @param clazz

	 * @return

	 */

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

	    List terms = cachedTermMap.get(termVocabulary);

	    if(terms==null){

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

	        cachedTermMap.put(termVocabulary, terms);

	    }

	    return terms;

	}

	/**

    *

    * @param clazz

    * @return

    */

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

       if (comp == null){

           comp = new DefaultTermComparator<T>();

       }

       List terms = cachedTermMap.get(termVocabulary);

       if(terms==null){

           terms = getFilteredTerms(new ArrayList<T>(TermStore.getTerms(termVocabulary,comp)));

           cachedTermMap.put(termVocabulary, terms);

       }

       terms.sort(comp);

       return terms;

   }

	/**

	 *

	 * @param clazz

	 * @return

	 */

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

	    List terms = cachedTermMap.get(clazz);

	    if(terms==null){

	        terms = getFilteredTerms(TermStore.getTerms(clazz));

	        cachedTermMap.put(clazz, terms);

	    }

	    return terms;

	}

	/**

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

		for (T term : initialTerms){

			if (term instanceof TaxonRelationshipTypeInverseContainer){

				if(!PreferencesUtil.getBooleanValue(getPrefName(term))){

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

					filteredTerms.add(type);

				}

			}

			if(!PreferencesUtil.getBooleanValue(getPrefName(term))){

				filteredTerms.add(term);

			}

		}

		return filteredTerms;

	}

    private <T extends TermBase> String getPrefName(T term) {

        return term.getTermType()!=null?term.getTermType().toString()+term.getUuid().toString():""+term.getUuid().toString();

    }

	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;

	}

	/**

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

				PreferencesUtil.setBooleanValue(getPrefName(term), true);

			}else{

			    PreferencesUtil.setBooleanValue(getPrefName(term), false);

			}

		}

	}

	public void clearTermMapForTermType(TermType termType){

	    cachedTermMap.remove(termType);

	}

	/**

     * 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> getTerms(List<UUID> uuidList, Class clazz){

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

        List<T> terms = TermStore.getTerms(clazz);

        if (uuidList.isEmpty()){

            return terms;

        }

        for (T term : terms){

            if(uuidList.contains(term.getUuid())){

                filteredTerms.add(term);

            }

        }

        return filteredTerms;

    }

}