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.cdm.api.service;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.TreeMap;

import java.util.UUID;

import java.util.stream.Collectors;

import javax.persistence.EntityNotFoundException;

import org.apache.commons.collections.CollectionUtils;

import org.apache.commons.lang.StringUtils;

import org.apache.log4j.Logger;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import eu.etaxonomy.cdm.api.service.config.CreateHierarchyForClassificationConfigurator;

import eu.etaxonomy.cdm.api.service.config.NodeDeletionConfigurator.ChildHandling;

import eu.etaxonomy.cdm.api.service.config.TaxonDeletionConfigurator;

import eu.etaxonomy.cdm.api.service.dto.EntityDTO;

import eu.etaxonomy.cdm.api.service.dto.GroupedTaxonDTO;

import eu.etaxonomy.cdm.api.service.dto.MarkedEntityDTO;

import eu.etaxonomy.cdm.api.service.dto.TaxonInContextDTO;

import eu.etaxonomy.cdm.api.service.pager.Pager;

import eu.etaxonomy.cdm.api.service.pager.PagerUtils;

import eu.etaxonomy.cdm.api.service.pager.impl.AbstractPagerImpl;

import eu.etaxonomy.cdm.api.service.pager.impl.DefaultPagerImpl;

import eu.etaxonomy.cdm.common.monitor.IProgressMonitor;

import eu.etaxonomy.cdm.exception.FilterException;

import eu.etaxonomy.cdm.exception.UnpublishedException;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import eu.etaxonomy.cdm.persistence.dao.initializer.IBeanInitializer;

import eu.etaxonomy.cdm.persistence.dao.taxon.IClassificationDao;

import eu.etaxonomy.cdm.persistence.dao.taxon.ITaxonDao;

import eu.etaxonomy.cdm.persistence.dao.taxon.ITaxonNodeDao;

import eu.etaxonomy.cdm.persistence.dao.term.IDefinedTermDao;

import eu.etaxonomy.cdm.persistence.dto.ClassificationLookupDTO;

import eu.etaxonomy.cdm.persistence.dto.TaxonNodeDto;

import eu.etaxonomy.cdm.persistence.dto.TaxonStatus;

import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;

import eu.etaxonomy.cdm.persistence.query.OrderHint;

import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy;

import eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl;

/**

 * @author n.hoffmann

 * @since Sep 21, 2009

 */

@Service

@Transactional(readOnly = true)

public class ClassificationServiceImpl

             extends IdentifiableServiceBase<Classification, IClassificationDao>

             implements IClassificationService {

    private static final Logger logger = Logger.getLogger(ClassificationServiceImpl.class);

    @Autowired

    private ITaxonNodeDao taxonNodeDao;

    @Autowired

    private ITaxonDao taxonDao;

    @Autowired

    private ITaxonNodeService taxonNodeService;

    @Autowired

    private IDefinedTermDao termDao;

    @Autowired

    private IBeanInitializer defaultBeanInitializer;

    @Override

    @Autowired

    protected void setDao(IClassificationDao dao) {

        this.dao = dao;

    }

    private Comparator<? super TaxonNode> taxonNodeComparator;

    @Autowired

    public void setTaxonNodeComparator(ITaxonNodeComparator<? super TaxonNode> taxonNodeComparator){

        this.taxonNodeComparator = (Comparator<? super TaxonNode>) taxonNodeComparator;

    }

    @Override

    public TaxonNode loadTaxonNodeByTaxon(Taxon taxon, UUID classificationUuid, List<String> propertyPaths){

        Classification tree = dao.load(classificationUuid);

        TaxonNode node = tree.getNode(taxon);

        return loadTaxonNode(node.getUuid(), propertyPaths);

    }

    public TaxonNode loadTaxonNode(UUID taxonNodeUuid, List<String> propertyPaths){

        return taxonNodeDao.load(taxonNodeUuid, propertyPaths);

    }

    @Override

    public List<TaxonNode> listRankSpecificRootNodes(Classification classification,

            TaxonNode subtree, Rank rank,

            boolean includeUnpublished, Integer pageSize, Integer pageIndex, List<String> propertyPaths) {

        return pageRankSpecificRootNodes(classification, subtree, rank, includeUnpublished, pageSize, pageIndex, propertyPaths).getRecords();

    }

    @Override

    public List<TaxonNodeDto> listRankSpecificRootNodeDtos(Classification classification, TaxonNode subtree,

            Rank rank, boolean includeUnpublished, Integer pageSize, Integer pageIndex, TaxonNodeDtoSortMode sortMode,

            List<String> propertyPaths) {

        List<TaxonNode> list = listRankSpecificRootNodes(classification, subtree, rank, includeUnpublished, pageSize, pageIndex, propertyPaths);

        return list.stream().filter(e ->  e != null).map(e -> new TaxonNodeDto(e)).sorted(sortMode.newComparator()).collect(Collectors.toList());

    }

    @Override

    public Pager<TaxonNode> pageRankSpecificRootNodes(Classification classification, Rank rank,

            boolean includeUnpublished, Integer pageSize, Integer pageIndex, List<String> propertyPaths) {

        return pageRankSpecificRootNodes(classification, null, rank, includeUnpublished, pageSize, pageIndex, propertyPaths);

    }

    @Override

    public Pager<TaxonNode> pageRankSpecificRootNodes(Classification classification, TaxonNode subtree, Rank rank,

            boolean includeUnpublished, Integer pageSize, Integer pageIndex, List<String> propertyPaths) {

        long[] numberOfResults = dao.countRankSpecificRootNodes(classification, subtree, includeUnpublished, rank);

        long totalNumberOfResults = numberOfResults[0] + (numberOfResults.length > 1 ? numberOfResults[1] : 0);

        List<TaxonNode> results = new ArrayList<>();

        if (AbstractPagerImpl.hasResultsInRange(totalNumberOfResults, pageIndex, pageSize)) { // no point checking again

            Integer limit = PagerUtils.limitFor(pageSize);

            Integer start = PagerUtils.startFor(pageSize, pageIndex);

            Integer remainingLimit = limit;

            int[] queryIndexes = rank == null ? new int[]{0} : new int[]{0,1};

            for(int queryIndex: queryIndexes) {

                if(start != null && start > numberOfResults[queryIndex]) {

                    // start in next query with new start value

                    start = start - (int)numberOfResults[queryIndex];

                    continue;

                }

                List<TaxonNode> perQueryResults = dao.listRankSpecificRootNodes(classification,

                        subtree, rank, includeUnpublished, remainingLimit,

                        start, propertyPaths, queryIndex);

                results.addAll(perQueryResults);

                if(remainingLimit != null ){

                    remainingLimit = remainingLimit - results.size();

                    if(remainingLimit <= 0) {

                        // no need to run further queries if first query returned enough items!

                        break;

                    }

                    // start at with fist item of next query to fetch the remaining items

                    start = 0;

                }

            }

        }

//        long start_t = System.currentTimeMillis();

        Collections.sort(results, taxonNodeComparator); // TODO is ordering during the hibernate query in the dao possible?

//        System.err.println("service.pageRankSpecificRootNodes() - Collections.sort(results,  taxonNodeComparator) " + (System.currentTimeMillis() - start_t));

        return new DefaultPagerImpl<>(pageIndex, totalNumberOfResults, pageSize, results);

    }

    @Override

    public List<TaxonNode> loadTreeBranch(TaxonNode taxonNode, Rank baseRank,

            boolean includeUnpublished, List<String> propertyPaths) throws UnpublishedException{

        return loadTreeBranch(taxonNode, null, baseRank, includeUnpublished, propertyPaths);

    }

    @Override

    public List<TaxonNode> loadTreeBranch(TaxonNode taxonNode, TaxonNode subtree, Rank baseRank,

            boolean includeUnpublished, List<String> propertyPaths) throws UnpublishedException{

        TaxonNode thisNode = taxonNodeDao.load(taxonNode.getUuid(), propertyPaths);

        if(baseRank != null){

            baseRank = (Rank) termDao.load(baseRank.getUuid());

        }

        if (!includeUnpublished && thisNode.getTaxon() != null && !thisNode.getTaxon().isPublish()){

            throw new UnpublishedException("Final taxon in tree branch is unpublished.");

        }

        List<TaxonNode> pathToRoot = new ArrayList<>();

        pathToRoot.add(thisNode);

        while(!thisNode.isTopmostNode()){

            //TODO why do we need to deproxy here?

            //     without this thisNode.getParent() will return NULL in

            //     some cases (environment dependend?) even if the parent exits

            TaxonNode parentNode = CdmBase.deproxy(thisNode).getParent();

            if(parentNode == null){

                throw new NullPointerException("Taxon node " + thisNode + " must have a parent since it is not top most");

            }

            if(parentNode.getTaxon() == null){

                throw new NullPointerException("The taxon associated with taxon node " + parentNode + " is NULL");

            }

            if(!includeUnpublished && !parentNode.getTaxon().isPublish()){

                throw new UnpublishedException("Some taxon in tree branch is unpublished.");

            }

            if(parentNode.getTaxon().getName() == null){

                throw new NullPointerException("The name of the taxon associated with taxonNode " + parentNode + " is NULL");

            }

            Rank parentNodeRank = (parentNode.getTaxon().getName() == null) ? null : parentNode.getTaxon().getName().getRank();

            // stop if the next parent is higher than the baseRank

            if(baseRank != null && parentNodeRank != null && baseRank.isLower(parentNodeRank)){

                break;

            }

            if((subtree!= null && !subtree.isAncestor(parentNode) )){

                break;

            }

            pathToRoot.add(parentNode);

            thisNode = parentNode;

        }

        // initialize and invert order of nodes in list

        defaultBeanInitializer.initializeAll(pathToRoot, propertyPaths);

        Collections.reverse(pathToRoot);

        return pathToRoot;

    }

    @Override

    public List<TaxonNode> loadTreeBranchToTaxon(Taxon taxon, Classification classification, Rank baseRank,

            boolean includeUnpublished, List<String> propertyPaths) throws UnpublishedException{

        return loadTreeBranchToTaxon(taxon, classification, null, baseRank, includeUnpublished, propertyPaths);

    }

    @Override

    public List<TaxonNodeDto> loadTreeBranchDTOsToTaxon(Taxon taxon, Classification classification,

            TaxonNode subtree, Rank baseRank,

            boolean includeUnpublished, List<String> propertyPaths) throws UnpublishedException {

        List<TaxonNode> list = loadTreeBranchToTaxon(taxon, classification, subtree, baseRank, includeUnpublished, propertyPaths);

        return list.stream().map(e -> new TaxonNodeDto(e)).collect(Collectors.toList());

    }

    @Override

    public List<TaxonNode> loadTreeBranchToTaxon(Taxon taxon, Classification classification,

            TaxonNode subtree, Rank baseRank,

            boolean includeUnpublished, List<String> propertyPaths) throws UnpublishedException{

        UUID nodeUuid = getTaxonNodeUuidByTaxonUuid(classification.getUuid(), taxon.getUuid());

        TaxonNode node = taxonNodeService.find(nodeUuid);

        if(node == null){

            logger.warn("The specified taxon is not found in the given tree.");

            return null;

        }else if (subtree != null && !node.isDescendant(subtree)){

            //TODO handle as exception? E.g. FilterException, AccessDeniedException?

            logger.warn("The specified taxon is not found for the given subtree.");

            return null;

        }

        return loadTreeBranch(node, subtree, baseRank, includeUnpublished, propertyPaths);

    }

    @Override

    public List<TaxonNode> loadChildNodesOfTaxonNode(TaxonNode taxonNode,

            List<String> propertyPaths) {

        taxonNode = taxonNodeDao.load(taxonNode.getUuid());

        List<TaxonNode> childNodes = new ArrayList<TaxonNode>(taxonNode.getChildNodes());

        defaultBeanInitializer.initializeAll(childNodes, propertyPaths);

        Collections.sort(childNodes, taxonNodeComparator);

        return childNodes;

    }

    @Override

    public List<TaxonNode> listChildNodesOfTaxon(UUID taxonUuid, UUID classificationUuid,

            boolean includeUnpublished, Integer pageSize, Integer pageIndex, List<String> propertyPaths){

        try {

            return listChildNodesOfTaxon(taxonUuid, classificationUuid, null, includeUnpublished, pageSize, pageIndex, propertyPaths);

        } catch (FilterException e) {

            throw new RuntimeException(e);  //this should not happen as filter is null

        }

    }

    @Override

    public List<TaxonNode> listChildNodesOfTaxon(UUID taxonUuid, UUID classificationUuid, UUID subtreeUuid,

            boolean includeUnpublished, Integer pageSize, Integer pageIndex, List<String> propertyPaths) throws FilterException{

        Classification classification = dao.load(classificationUuid);

        Taxon taxon = (Taxon) taxonDao.load(taxonUuid);

        TaxonNode subtree = taxonNodeDao.load(subtreeUuid);

        if (subtreeUuid != null && subtree == null){

            throw new FilterException("Taxon node for subtree filter can not be found in database", true);

        }

        List<TaxonNode> results = dao.listChildrenOf(

                taxon, classification, subtree, includeUnpublished, pageSize, pageIndex, propertyPaths);

        Collections.sort(results, taxonNodeComparator); // FIXME this is only a HACK, order during the hibernate query in the dao

        return results;

    }

    @Override

    public List<TaxonNodeDto> listChildNodeDtosOfTaxon(UUID taxonUuid, UUID classificationUuid, UUID subtreeUuid, boolean includeUnpublished,

            Integer pageSize, Integer pageIndex, TaxonNodeDtoSortMode sortMode, List<String> propertyPaths) throws FilterException{

        Classification classification = dao.load(classificationUuid);

        Taxon taxon = (Taxon) taxonDao.load(taxonUuid);

        TaxonNode subtree = taxonNodeDao.load(subtreeUuid);

        if (subtreeUuid != null && subtree == null){

            throw new FilterException("Taxon node for subtree filter can not be found in database", true);

        }

        List<TaxonNode> results = dao.listChildrenOf(

                taxon, classification, subtree, includeUnpublished, pageSize, pageIndex, propertyPaths);

        Comparator<TaxonNodeDto> comparator = sortMode.newComparator();

        // TODO order during the hibernate query in the dao?

        List<TaxonNodeDto> dtos = results.stream().map(e -> new TaxonNodeDto(e)).sorted(comparator).collect(Collectors.toList());

        return dtos;

    }

    @Override

    public Pager<TaxonNode> pageSiblingsOfTaxon(UUID taxonUuid, UUID classificationUuid, boolean includeUnpublished,

            Integer pageSize, Integer pageIndex, List<String> propertyPaths){

        Classification classification = dao.load(classificationUuid);

        Taxon taxon = (Taxon) taxonDao.load(taxonUuid);

        long numberOfResults = dao.countSiblingsOf(taxon, classification, includeUnpublished);

        List<TaxonNode> results;

        if(PagerUtils.hasResultsInRange(numberOfResults, pageIndex, pageSize)) {

            results = dao.listSiblingsOf(taxon, classification, includeUnpublished, pageSize, pageIndex, propertyPaths);

            Collections.sort(results, taxonNodeComparator); // FIXME this is only a HACK, order during the hibernate query in the dao

        } else {

            results = new ArrayList<>();

        }

        return new DefaultPagerImpl<>(pageIndex, numberOfResults, pageSize, results);

    }

    @Override

    public List<TaxonNode> listSiblingsOfTaxon(UUID taxonUuid, UUID classificationUuid, boolean includeUnpublished,

            Integer pageSize, Integer pageIndex, List<String> propertyPaths){

        Pager<TaxonNode> pager = pageSiblingsOfTaxon(taxonUuid, classificationUuid, includeUnpublished, pageSize, pageIndex, propertyPaths);

        return pager.getRecords();

    }

    @Override

    public ITaxonTreeNode getTreeNodeByUuid(UUID uuid){

        ITaxonTreeNode treeNode = taxonNodeDao.findByUuid(uuid);

        if(treeNode == null){

            treeNode = dao.findByUuid(uuid);

        }

        return treeNode;

    }

    @Override

    public TaxonNode getRootNode(UUID classificationUuid){

        return dao.getRootNode(classificationUuid);

    }

    @Override

    public List<Classification> listClassifications(Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {

        return dao.list(limit, start, orderHints, propertyPaths);

    }

    @Override

    public UUID removeTreeNode(ITaxonTreeNode treeNode) {

        if(treeNode instanceof Classification){

            return dao.delete((Classification) treeNode);

        }else if(treeNode instanceof TaxonNode){

            return taxonNodeDao.delete((TaxonNode)treeNode);

        }

        return null;

    }

    @Override

    public Map<UUID, TaxonNode> saveTaxonNodeAll(

            Collection<TaxonNode> taxonNodeCollection) {

        return taxonNodeDao.saveAll(taxonNodeCollection);

    }

    @Override

    public UUID saveClassification(Classification classification) {

       taxonNodeDao.saveOrUpdateAll(classification.getAllNodes());

       UUID result =dao.saveOrUpdate(classification);

       return result;

    }

    @Override

    public UUID saveTreeNode(ITaxonTreeNode treeNode) {

        if(treeNode instanceof Classification){

            return dao.save((Classification) treeNode).getUuid();

        }else if(treeNode instanceof TaxonNode){

            return taxonNodeDao.save((TaxonNode)treeNode).getUuid();

        }

        return null;

    }

    @Override

    public List<TaxonNode> getAllNodes(){

        return taxonNodeDao.list(null,null);

    }

    @Override

    public List<UuidAndTitleCache<TaxonNode>> getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(UUID classificationUuid, Integer limit, String pattern, boolean searchForClassifications, boolean includeDoubtful) {

        return taxonNodeDao.getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(dao.load(classificationUuid),  limit, pattern, searchForClassifications, includeDoubtful);

    }

    @Override

    public List<UuidAndTitleCache<TaxonNode>> getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(Classification classification,  Integer limit, String pattern, boolean searchForClassifications) {

        return taxonNodeDao.getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(classification,  limit, pattern, searchForClassifications);

    }

    @Override

    public List<UuidAndTitleCache<TaxonNode>> getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(UUID classificationUuid, boolean searchForClassifications ) {

        return taxonNodeDao.getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(dao.load(classificationUuid), null, null, searchForClassifications);

    }

    @Override

    public List<UuidAndTitleCache<TaxonNode>> getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(Classification classification, boolean searchForClassifications ) {

        return taxonNodeDao.getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(classification, null, null, searchForClassifications);

    }

    @Override

    public List<UuidAndTitleCache<Classification>> getUuidAndTitleCache(Integer limit, String pattern) {

        return dao.getUuidAndTitleCache(limit, pattern);

    }

    @Override

    public Map<UUID, List<MediaRepresentation>> getAllMediaForChildNodes(

            TaxonNode taxonNode, List<String> propertyPaths, int size,

            int height, int widthOrDuration, String[] mimeTypes) {

        TreeMap<UUID, List<MediaRepresentation>> result = new TreeMap<>();

        List<MediaRepresentation> mediaRepresentations = new ArrayList<>();

        //add all media of the children to the result map

        if (taxonNode != null){

            List<TaxonNode> nodes = new ArrayList<>();

            nodes.add(loadTaxonNode(taxonNode.getUuid(), propertyPaths));

            nodes.addAll(loadChildNodesOfTaxonNode(taxonNode, propertyPaths));

            for(TaxonNode node : nodes){

                Taxon taxon = node.getTaxon();

                for (TaxonDescription taxonDescription: taxon.getDescriptions()){

                    for (DescriptionElementBase descriptionElement: taxonDescription.getElements()){

                        for(Media media : descriptionElement.getMedia()){

                            //find the best matching representation

                            mediaRepresentations.add(MediaUtils.findBestMatchingRepresentation(media,null, size, height, widthOrDuration, mimeTypes, MediaUtils.MissingValueStrategy.MAX));

                        }

                    }

                }

                result.put(taxon.getUuid(), mediaRepresentations);

            }

        }

        return result;

    }

    @Override

    @Transactional(readOnly = false)

    public UpdateResult updateCaches(Class<? extends Classification> clazz, Integer stepSize, IIdentifiableEntityCacheStrategy<Classification> cacheStrategy, IProgressMonitor monitor) {

        if (clazz == null){

            clazz = Classification.class;

        }

        return super.updateCachesImpl(clazz, stepSize, cacheStrategy, monitor);

    }

    /**

     *

     * @param allNodesOfClassification

     * @return null - if  allNodesOfClassification is empty <br>

     */

    private Map<String, List<TaxonNode>> getSortedGenusList(Collection<TaxonNode> allNodesOfClassification){

    	if(allNodesOfClassification == null || allNodesOfClassification.isEmpty()){

    		return null;

    	}

    	Map<String, List<TaxonNode>> sortedGenusMap = new HashMap<>();

    	for(TaxonNode node:allNodesOfClassification){

    		Taxon taxon = node.getTaxon();

    		INonViralName name = taxon.getName();

    		String genusOrUninomial = name.getGenusOrUninomial();

    		//if rank unknown split string and take first word

    		if(genusOrUninomial == null){

    			String titleCache = taxon.getTitleCache();

    			String[] split = titleCache.split("\\s+");

    			for(String s:split){

    				genusOrUninomial = s;

    				break;

    			}

    		}

    		//if node has children

    		//retrieve list from map if not create List

    		if(sortedGenusMap.containsKey(genusOrUninomial)){

    			List<TaxonNode> list = sortedGenusMap.get(genusOrUninomial);

    			list.add(node);

    			sortedGenusMap.put(genusOrUninomial, list);

    		}else{

    			//create List for genus

    			List<TaxonNode> list = new ArrayList<>();

    			list.add(node);

    			sortedGenusMap.put(genusOrUninomial, list);

    		}

    	}

    	return sortedGenusMap;

    }

    /**

     *

     * creates new Classification and parent TaxonNodes at genus level

     *

     *

     * @param map GenusMap which holds a name (Genus) and all the same Taxa as a list

     * @param classification you want to improve the hierarchy (will not be modified)

     * @param configurator to change certain settings, if null then standard settings will be taken

     * @return new classification with parentNodes for each entry in the map

     */

    @SuppressWarnings({ "unchecked" })

	@Transactional(readOnly = false)

	@Override

    public UpdateResult createHierarchyInClassification(Classification classification, CreateHierarchyForClassificationConfigurator configurator){

        UpdateResult result = new UpdateResult();

    	classification = dao.findByUuid(classification.getUuid());

    	Map<String, List<TaxonNode>> map = getSortedGenusList(classification.getAllNodes());

    	final String APPENDIX = "repaired";

    	String titleCache = StringUtils.isBlank(classification.getTitleCache()) ? " " : classification.getTitleCache() ;

    	//TODO classification clone???

    	Classification newClassification = Classification.NewInstance(titleCache +" "+ APPENDIX);

    	newClassification.setReference(classification.getReference());

    	for(Map.Entry<String, List<TaxonNode>> entry:map.entrySet()){

    		String genus = entry.getKey();

    		List<TaxonNode> listOfTaxonNodes = entry.getValue();

    		TaxonNode parentNode = null;

    		//Search for genus in list

    		for(TaxonNode tNode:listOfTaxonNodes){

    			//take that taxonNode as parent and remove from list with all it possible children

    			//FIXME NPE for name

    			TaxonName name = tNode.getTaxon().getName();

    			if(name.getNameCache().equalsIgnoreCase(genus)){

    				TaxonNode clone = tNode.clone();

    				if(!tNode.hasChildNodes()){

    					//FIXME remove classification

//    					parentNode = newClassification.addChildNode(clone, 0, classification.getCitation(), classification.getMicroReference());

    					parentNode = newClassification.addChildNode(clone, 0, clone.getReference(), clone.getMicroReference());

    					//remove taxonNode from list because just added to classification

    					result.addUpdatedObject(tNode);

    					listOfTaxonNodes.remove(tNode);

    				}else{

    					//get all childNodes

    					//save prior Hierarchy and remove them from the list

    					List<TaxonNode> copyAllChildrenToTaxonNode = copyAllChildrenToTaxonNode(tNode, clone, result);

//    					parentNode = newClassification.addChildNode(clone, 0, classification.getCitation(), classification.getMicroReference());

      					//FIXME remove classification

    					parentNode = newClassification.addChildNode(clone, 0, clone.getReference(), clone.getMicroReference());

    					//remove taxonNode from list because just added to classification

    					result.addUpdatedObject(tNode);

    					listOfTaxonNodes.remove(tNode);

    					if(copyAllChildrenToTaxonNode != null){

    						listOfTaxonNodes = (List<TaxonNode>) CollectionUtils.removeAll(listOfTaxonNodes, copyAllChildrenToTaxonNode);

    					}

    				}

    				break;

    			}

    		}

    		if(parentNode == null){

    			//if no match found in list, create parentNode

    			NonViralNameParserImpl parser = NonViralNameParserImpl.NewInstance();

    			TaxonName TaxonName = (TaxonName)parser.parseFullName(genus);

    			//TODO Sec via configurator

    			Taxon taxon = Taxon.NewInstance(TaxonName, null);

    			parentNode = newClassification.addChildTaxon(taxon, 0, null, null);

    			result.addUpdatedObject(parentNode);

    		}

    		//iterate over the rest of the list

    		for(TaxonNode tn : listOfTaxonNodes){

    			//if TaxonNode has a parent and this is not the classification then skip it

    			//and add to new classification via the parentNode as children of it

    			//this should assures to keep the already existing hierarchy

    			//FIXME: Assert is not rootnode --> entrypoint is not classification in future but rather rootNode

    			if(!tn.isTopmostNode()){

    				continue; //skip to next taxonNode

    			}

    			TaxonNode clone = tn.clone();

    			//FIXME: citation from node

    			//TODO: addchildNode without citation and references

//    			TaxonNode taxonNode = parentNode.addChildNode(clone, classification.getCitation(), classification.getMicroReference());

    			TaxonNode taxonNode = parentNode.addChildNode(clone, clone.getReference(), clone.getMicroReference());

    			result.addUnChangedObject(clone);

    			if(tn.hasChildNodes()){

    				//save hierarchy in new classification

    				List<TaxonNode> copyAllChildrenToTaxonNode = copyAllChildrenToTaxonNode(tn, taxonNode, result);

    				if(copyAllChildrenToTaxonNode != null){

    					listOfTaxonNodes = (List<TaxonNode>) CollectionUtils.removeAll(listOfTaxonNodes, copyAllChildrenToTaxonNode);

    				}

    			}

    		}

    	}

    	dao.saveOrUpdate(newClassification);

    	result.setCdmEntity(newClassification);

    	return result;

    }

    /**

     *

     * recursive method to get all childnodes of taxonNode in classification.

     *

     * @param classification just for References and Citation, can be null

     * @param copyFromNode TaxonNode with Children

     * @param copyToNode TaxonNode which will receive the children

     * @return List of ChildNode which has been added. If node has no children returns null

     */

   private List<TaxonNode> copyAllChildrenToTaxonNode(TaxonNode copyFromNode, TaxonNode copyToNode, UpdateResult result) {

		List<TaxonNode> childNodes;

		if(!copyFromNode.hasChildNodes()){

			return null;

		}else{

			childNodes = copyFromNode.getChildNodes();

		}

		for(TaxonNode childNode:childNodes){

			TaxonNode clone = childNode.clone();

			result.addUnChangedObject(clone);

			if(childNode.hasChildNodes()){

				copyAllChildrenToTaxonNode(childNode, clone, result);

			}

			//FIXME: citation from node instead of classification

//			copyToNode.addChildNode(clone,classification.getCitation(), classification.getMicroReference());

			copyToNode.addChildNode(clone, clone.getReference(), clone.getMicroReference());

		}

		return childNodes;

	}

    @Override

    public ClassificationLookupDTO classificationLookup(Classification classification) {

        return dao.classificationLookup(classification);

    }

    @Override

    @Transactional

    public DeleteResult delete(UUID classificationUuid, TaxonDeletionConfigurator config){

        DeleteResult result = new DeleteResult();

        Classification classification = dao.findByUuid(classificationUuid);

        if (classification == null){

            result.addException(new IllegalArgumentException("The classification does not exist in database."));

            result.setAbort();

            return result;

        }

        if (!classification.hasChildNodes()){

            dao.delete(classification);

            result.addDeletedObject(classification);

            return result;

        }

        if (config.getTaxonNodeConfig().getChildHandling().equals(ChildHandling.DELETE)){

//            TaxonNode root = classification.getRootNode();

//            result.includeResult(taxonNodeService.deleteTaxonNode(HibernateProxyHelper.deproxy(root), config));

//            result.addDeletedObject(classification);

            dao.delete(classification);

            result.addDeletedObject(classification);

            return result;

        }

        return result;

    }

    @Override

    public List<GroupedTaxonDTO> groupTaxaByHigherTaxon(List<UUID> originalTaxonUuids, UUID classificationUuid, Rank minRank, Rank maxRank){

        List<GroupedTaxonDTO> result = new ArrayList<>();

        //get treeindex for each taxonUUID

        Map<UUID, TreeIndex> taxonIdTreeIndexMap = dao.treeIndexForTaxonUuids(classificationUuid, originalTaxonUuids);

        //build treeindex list (or tree)

        //TODO make it work with TreeIndex or move there

        List<String> treeIndexClosureStr = new ArrayList<>();

        for (TreeIndex treeIndex : taxonIdTreeIndexMap.values()){

            String[] splits = treeIndex.toString().substring(1).split(ITreeNode.separator);

            String currentIndex = ITreeNode.separator;

            for (String split : splits){

                if (split.equals("")){

                    continue;

                }

                currentIndex += split + ITreeNode.separator;

                if (!treeIndexClosureStr.contains(currentIndex) && !split.startsWith(ITreeNode.treePrefix)){

                    treeIndexClosureStr.add(currentIndex);

                }

            }

        }

        //get rank sortindex for all parent taxa with sortindex <= minRank and sortIndex >= maxRank (if available)

        Integer minRankOrderIndex = minRank == null ? null : minRank.getOrderIndex();

        Integer maxRankOrderIndex = maxRank == null ? null : maxRank.getOrderIndex();

        List<TreeIndex> treeIndexClosure = TreeIndex.NewListInstance(treeIndexClosureStr);

        Map<TreeIndex, Integer> treeIndexSortIndexMapTmp = taxonNodeDao.rankOrderIndexForTreeIndex(treeIndexClosure, minRankOrderIndex, maxRankOrderIndex);

        //remove all treeindex with "exists child in above map(and child.sortindex > xxx)

        List<TreeIndex> treeIndexList = TreeIndex.sort(treeIndexSortIndexMapTmp.keySet());

        Map<TreeIndex, Integer> treeIndexSortIndexMap = new HashMap<>();

        TreeIndex lastTreeIndex = null;

        for (TreeIndex treeIndex : treeIndexList){

            if (lastTreeIndex != null && lastTreeIndex.hasChild(treeIndex)){

                treeIndexSortIndexMap.remove(lastTreeIndex);

            }

            treeIndexSortIndexMap.put(treeIndex, treeIndexSortIndexMapTmp.get(treeIndex));

            lastTreeIndex = treeIndex;

        }

        //get taxonID for treeIndexes

        Map<TreeIndex, UuidAndTitleCache<?>> treeIndexTaxonIdMap = taxonNodeDao.taxonUuidsForTreeIndexes(treeIndexSortIndexMap.keySet());

        //fill result list

        for (UUID originalTaxonUuid : originalTaxonUuids){

            GroupedTaxonDTO item = new GroupedTaxonDTO();

            result.add(item);

            item.setTaxonUuid(originalTaxonUuid);

            TreeIndex groupTreeIndex = taxonIdTreeIndexMap.get(originalTaxonUuid);

            String groupIndexX = TreeIndex.toString(groupTreeIndex);