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

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.UUID;

import java.util.stream.Collectors;

import org.apache.commons.lang.StringUtils;

import org.apache.log4j.Logger;

import org.hibernate.Query;

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

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import eu.etaxonomy.cdm.api.service.description.MissingMaximumMode;

import eu.etaxonomy.cdm.api.service.description.MissingMinimumMode;

import eu.etaxonomy.cdm.api.service.description.StructuredDescriptionAggregation;

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

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

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

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

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

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

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

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

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.format.description.MicroFormatQuantitativeDescriptionBuilder;

import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import eu.etaxonomy.cdm.model.location.NamedArea;

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

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

import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;

import eu.etaxonomy.cdm.model.reference.CdmLinkSource;

import eu.etaxonomy.cdm.model.reference.ICdmTarget;

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

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

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

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

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

import eu.etaxonomy.cdm.persistence.dao.description.IDescriptionDao;

import eu.etaxonomy.cdm.persistence.dao.description.IDescriptionElementDao;

import eu.etaxonomy.cdm.persistence.dao.description.IDescriptiveDataSetDao;

import eu.etaxonomy.cdm.persistence.dao.description.IStatisticalMeasurementValueDao;

import eu.etaxonomy.cdm.persistence.dao.name.ITaxonNameDao;

import eu.etaxonomy.cdm.persistence.dao.occurrence.IOccurrenceDao;

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.dao.term.ITermNodeDao;

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

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

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

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

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

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

/**

 * @author a.mueller

 * @author a.kohlbecker

 *

 * @since 24.06.2008

 */

@Service

@Transactional(readOnly = true)

public class DescriptionServiceImpl

        extends IdentifiableServiceBase<DescriptionBase,IDescriptionDao>

        implements IDescriptionService {

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

    protected IDescriptionElementDao descriptionElementDao;

    protected ITermTreeDao featureTreeDao;

    protected IDescriptiveDataSetDao descriptiveDataSetDao;

    protected ITermNodeDao termNodeDao;

    protected ITermVocabularyDao vocabularyDao;

    protected IDefinedTermDao definedTermDao;

    protected IStatisticalMeasurementValueDao statisticalMeasurementValueDao;

    protected ITaxonDao taxonDao;

    protected ITaxonNameDao nameDao;

    protected IOccurrenceDao occurrenceDao;

    protected ITaxonNodeDao taxonNodeDao;

    protected IDescriptiveDataSetDao dataSetDao;

    //TODO change to Interface

    private NaturalLanguageGenerator naturalLanguageGenerator;

    @Autowired

    protected void setFeatureTreeDao(ITermTreeDao featureTreeDao) {

        this.featureTreeDao = featureTreeDao;

    }

    @Autowired

    protected void setDescriptiveDataSetDao(IDescriptiveDataSetDao descriptiveDataSetDao) {

        this.descriptiveDataSetDao = descriptiveDataSetDao;

    }

    @Autowired

    protected void setTermNodeDao(ITermNodeDao featureNodeDao) {

        this.termNodeDao = featureNodeDao;

    }

    @Autowired

    protected void setVocabularyDao(ITermVocabularyDao vocabularyDao) {

        this.vocabularyDao = vocabularyDao;

    }

    @Autowired

    protected void setDefinedTermDao(IDefinedTermDao definedTermDao) {

        this.definedTermDao = definedTermDao;

    }

    @Autowired

    protected void statisticalMeasurementValueDao(IStatisticalMeasurementValueDao statisticalMeasurementValueDao) {

        this.statisticalMeasurementValueDao = statisticalMeasurementValueDao;

    }

    @Autowired

    protected void setDescriptionElementDao(IDescriptionElementDao descriptionElementDao) {

        this.descriptionElementDao = descriptionElementDao;

    }

    @Autowired

    protected void setNaturalLanguageGenerator(NaturalLanguageGenerator naturalLanguageGenerator) {

        this.naturalLanguageGenerator = naturalLanguageGenerator;

    }

    @Autowired

    protected void setTaxonDao(ITaxonDao taxonDao) {

        this.taxonDao = taxonDao;

    }

    @Autowired

    protected void setTaxonNodeDao(ITaxonNodeDao taxonNodeDao) {

        this.taxonNodeDao = taxonNodeDao;

    }

    @Autowired

    protected void setDataSetDao(IDescriptiveDataSetDao dataSetDao) {

        this.dataSetDao = dataSetDao;

    }

    public DescriptionServiceImpl() {

        logger.debug("Load DescriptionService Bean");

    }

    @Override

    @Transactional(readOnly = false)

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

        if (clazz == null){

            clazz = DescriptionBase.class;

        }

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

    }

    @Override

    public TermVocabulary<Feature> getDefaultFeatureVocabulary(){

        String uuidFeature = "b187d555-f06f-4d65-9e53-da7c93f8eaa8";

        UUID featureUuid = UUID.fromString(uuidFeature);

        return vocabularyDao.findByUuid(featureUuid);

    }

    @Override

    @Autowired

    protected void setDao(IDescriptionDao dao) {

        this.dao = dao;

    }

    @Override

    public long count(Class<? extends DescriptionBase> type, Boolean hasImages, Boolean hasText,Set<Feature> feature) {

        return dao.countDescriptions(type, hasImages, hasText, feature);

    }

    @Override

    public <T extends DescriptionElementBase> Pager<T> pageDescriptionElements(DescriptionBase description, Class<? extends DescriptionBase> descriptionType,

            Set<Feature> features, Class<T> type, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {

        List<T> results = listDescriptionElements(description, descriptionType, features, type, pageSize, pageNumber, propertyPaths);

        return new DefaultPagerImpl<>(pageNumber, Integer.valueOf(results.size()).longValue(), pageSize, results);

    }

    @Override

    @Deprecated

    public <T extends DescriptionElementBase> Pager<T> getDescriptionElements(DescriptionBase description,

            Set<Feature> features, Class<T> type, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {

        return pageDescriptionElements(description, null, features, type, pageSize, pageNumber, propertyPaths);

    }

    @Override

    public <T extends DescriptionElementBase> List<T> listDescriptionElements(DescriptionBase description,

            Class<? extends DescriptionBase> descriptionType, Set<Feature> features, Class<T> type, Integer pageSize, Integer pageNumber,

            List<String> propertyPaths) {

        long numberOfResults = dao.countDescriptionElements(description, descriptionType, features, type);

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

        if(AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)) {

            results = dao.getDescriptionElements(description, descriptionType, features, type, pageSize, pageNumber, propertyPaths);

        }

        return results;

    }

    @Override

    @Deprecated

    public <T extends DescriptionElementBase> List<T> listDescriptionElements(DescriptionBase description,

            Set<Feature> features, Class<T> type, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {

        return listDescriptionElements(description, null, features, type, pageSize, pageNumber, propertyPaths);

    }

    @Override

    public Pager<Annotation> getDescriptionElementAnnotations(DescriptionElementBase annotatedObj, MarkerType status, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths){

        long numberOfResults = descriptionElementDao.countAnnotations(annotatedObj, status);

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

        if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)

            results = descriptionElementDao.getAnnotations(annotatedObj, status, pageSize, pageNumber, orderHints, propertyPaths);

        }

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

    }

    @Override

    public Pager<Media> getMedia(DescriptionElementBase descriptionElement,	Integer pageSize, Integer pageNumber, List<String> propertyPaths) {

        Long numberOfResults = descriptionElementDao.countMedia(descriptionElement);

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

        if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)

            results = descriptionElementDao.getMedia(descriptionElement, pageSize, pageNumber, propertyPaths);

        }

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

    }

    @Override

    public Pager<TaxonDescription> pageTaxonDescriptions(Taxon taxon, Set<DefinedTerm> scopes, Set<NamedArea> geographicalScope, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {

        Set<MarkerType> markerTypes = null;

        Set<DescriptionType> descriptionTypes = null;

        return pageTaxonDescriptions(taxon, scopes, geographicalScope, markerTypes, descriptionTypes, pageSize, pageNumber, propertyPaths);

    }

    @Override

    public List<TaxonDescription> listTaxonDescriptions(Taxon taxon, Set<DefinedTerm> scopes, Set<NamedArea> geographicalScope, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {

        Set<MarkerType> markerTypes = null;

        Set<DescriptionType> descriptionTypes = null;

        return listTaxonDescriptions(taxon, scopes, geographicalScope, markerTypes, descriptionTypes, pageSize, pageNumber, propertyPaths);

    }

    @Override

    public Pager<TaxonDescription> pageTaxonDescriptions(Taxon taxon, Set<DefinedTerm> scopes, Set<NamedArea> geographicalScope, Set<MarkerType> markerTypes, Set<DescriptionType> descriptionTypes, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {

        long numberOfResults = dao.countTaxonDescriptions(taxon, scopes, geographicalScope, markerTypes, descriptionTypes);

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

        if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)

            results = dao.listTaxonDescriptions(taxon, scopes, geographicalScope, markerTypes, descriptionTypes, pageSize, pageNumber, propertyPaths);

        }

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

    }

    @Override

    public List<TaxonDescription> listTaxonDescriptions(Taxon taxon, Set<DefinedTerm> scopes, Set<NamedArea> geographicalScope, Set<MarkerType> markerTypes, Set<DescriptionType> descriptionTypes, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {

        List<TaxonDescription> results = dao.listTaxonDescriptions(taxon, scopes, geographicalScope, markerTypes, descriptionTypes, pageSize, pageNumber, propertyPaths);

        return results;

    }

    @Override

    public List<Media> listTaxonDescriptionMedia(UUID taxonUuid, boolean limitToGalleries, Set<MarkerType> markerTypes, Integer pageSize, Integer pageNumber, List<String> propertyPaths){

        return this.dao.listTaxonDescriptionMedia(taxonUuid, limitToGalleries, markerTypes, pageSize, pageNumber, propertyPaths);

    }

    @Override

    public int countTaxonDescriptionMedia(UUID taxonUuid, boolean limitToGalleries, Set<MarkerType> markerTypes){

        return this.dao.countTaxonDescriptionMedia(taxonUuid, limitToGalleries, markerTypes);

    }

    @Override

    public Pager<TaxonNameDescription> getTaxonNameDescriptions(TaxonName name, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {

        long numberOfResults = dao.countTaxonNameDescriptions(name);

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

        if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)

            results = dao.getTaxonNameDescriptions(name, pageSize, pageNumber,propertyPaths);

        }

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

    }

    @Override

    public Pager<DescriptionBase> page(Class<? extends DescriptionBase> type, Boolean hasImages, Boolean hasText, Set<Feature> feature, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {

        long numberOfResults = dao.countDescriptions(type, hasImages, hasText, feature);

        @SuppressWarnings("rawtypes")

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

        if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)

            results = dao.listDescriptions(type, hasImages, hasText, feature, pageSize, pageNumber,orderHints,propertyPaths);

        }

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

    }

    /**

     * FIXME Candidate for harmonization

     * Rename: searchByDistribution

     */

    @Override

    public Pager<TaxonDescription> searchDescriptionByDistribution(Set<NamedArea> namedAreas, PresenceAbsenceTerm presence,	Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {

        long numberOfResults = dao.countDescriptionByDistribution(namedAreas, presence);

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

        if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)

            results = dao.searchDescriptionByDistribution(namedAreas, presence, pageSize, pageNumber,orderHints,propertyPaths);

        }

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

    }

    /**

     * FIXME Candidate for harmonization

     * move: descriptionElementService.search

     */

    @Override

//    public Pager<T> searchElements(Class<? extends T> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {

    public <S extends DescriptionElementBase> Pager<S> searchElements(Class<S> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {

        long numberOfResults = descriptionElementDao.count(clazz, queryString);

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

        if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)

            results = (List<S>)descriptionElementDao.search(clazz, queryString, pageSize, pageNumber, orderHints, propertyPaths);

        }

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

    }

    /**

     * FIXME Candidate for harmonization

     * descriptionElementService.find

     */

    @Override

    public DescriptionElementBase getDescriptionElementByUuid(UUID uuid) {

        return descriptionElementDao.findByUuid(uuid);

    }

    /**

     * FIXME Candidate for harmonization

     * descriptionElementService.load

     */

    @Override

    public DescriptionElementBase loadDescriptionElement(UUID uuid,	List<String> propertyPaths) {

        return descriptionElementDao.load(uuid, propertyPaths);

    }

    /**

     * FIXME Candidate for harmonization

     * descriptionElementService.save

     */

    @Override

    @Transactional(readOnly = false)

    public UUID saveDescriptionElement(DescriptionElementBase descriptionElement) {

        return descriptionElementDao.save(descriptionElement).getUuid();

    }

    /**

     * FIXME Candidate for harmonization

     * descriptionElementService.save

     */

    @Override

    @Transactional(readOnly = false)

    public Map<UUID, DescriptionElementBase> saveDescriptionElement(Collection<DescriptionElementBase> descriptionElements) {

        return descriptionElementDao.saveAll(descriptionElements);

    }

    @Override

    @Transactional(readOnly = false)

    public List<MergeResult<DescriptionBase>> mergeDescriptionElements(Collection<TaxonDistributionDTO> descriptionElements, boolean returnTransientEntity) {

        List<MergeResult<DescriptionBase>> mergedObjects = new ArrayList();

        for(TaxonDistributionDTO obj : descriptionElements) {

            Iterator<TaxonDescription> iterator = obj.getDescriptionsWrapper().getDescriptions().iterator();

            List<DescriptionBase> list = new ArrayList(obj.getDescriptionsWrapper().getDescriptions());

          //  Map<UUID, DescriptionBase> map = dao.saveOrUpdateAll(list);

//            MergeResult<DescriptionBase> mergeResult = new MergeResult<DescriptionBase>(mergedEntity, newEntities)

//            mergedObjects.add(map.values());

            while (iterator.hasNext()){

                TaxonDescription desc = iterator.next();

                mergedObjects.add(dao.merge(desc, returnTransientEntity));

            }

        }

        return mergedObjects;

    }

//

    @Override

    @Transactional(readOnly = false)

    public UpdateResult mergeDescriptions(Collection<DescriptionBaseDto> descriptions, UUID descriptiveDataSetUuid) {

//        List<<DescriptionBase>> mergedObjects = new ArrayList();

        UpdateResult result = new UpdateResult();

        DescriptiveDataSet dataSet = descriptiveDataSetDao.load(descriptiveDataSetUuid);

        Set<DescriptionBase> descriptionsOfDataSet = dataSet.getDescriptions();

        HashMap<UUID, DescriptionBase> descriptionSpecimenMap = new HashMap();

        for (DescriptionBase descriptionBase: descriptionsOfDataSet){

            if (descriptionBase.getDescribedSpecimenOrObservation() != null){

                descriptionSpecimenMap.put(descriptionBase.getDescribedSpecimenOrObservation().getUuid(), descriptionBase);

            }

        }

        MergeResult<DescriptionBase> mergeResult = null;

        for(DescriptionBaseDto descDto : descriptions) {

            UUID descriptionUUID = descDto.getDescriptionUuid();

            DescriptionBase description = load(descriptionUUID);

            UUID describedObjectUuid = null;

            if (description instanceof SpecimenDescription){

                describedObjectUuid = descDto.getSpecimenDto().getUuid();

            }else if (description instanceof TaxonDescription){

                describedObjectUuid = descDto.getTaxonDto().getUuid();

            }else if (description instanceof TaxonNameDescription){

                describedObjectUuid = descDto.getNameDto().getUuid();

            }

            DescriptionBase descSpecimen = descriptionSpecimenMap.get(describedObjectUuid);

            if (descSpecimen != null ){

//                TODO: elements are Dtos now, no cdm entities, needs to get the value and replace or create new description element

                Set<DescriptionElementDto> elements = new HashSet<>();

                for (Object element: descDto.getElements()){

                    elements.add((DescriptionElementDto)element);

                }

                DescriptionBase desc = descriptionSpecimenMap.get(describedObjectUuid);

//                description.setDescribedSpecimenOrObservation(null);

                Set<DescriptionElementBase> descriptionElements = desc.getElements();

                for (DescriptionElementDto descElement: elements){

                    UUID descElementUuid = descElement.getElementUuid();

                    List<DescriptionElementBase> equalUuidsElements = descriptionElements.stream().filter( e -> e.getUuid().equals(descElementUuid)).collect(Collectors.toList());

                    eu.etaxonomy.cdm.model.description.Feature feature =  DefinedTermBase.getTermByClassAndUUID(eu.etaxonomy.cdm.model.description.Feature.class, descElement.getFeatureUuid());

                    if (feature == null){

                        feature = DefinedTermBase.getTermByClassAndUUID(eu.etaxonomy.cdm.model.description.Character.class, descElement.getFeatureUuid());

                    }

                    if (equalUuidsElements.size() == 0){

                        if (descElement instanceof CategoricalDataDto){

                            CategoricalData elementBase = CategoricalData.NewInstance(feature);

                            List<StateDataDto> stateDtos = ((CategoricalDataDto)descElement).getStates();

                            for (StateDataDto dataDto: stateDtos){

                                //create new statedata

                                State newState = DefinedTermBase.getTermByClassAndUUID(State.class, dataDto.getState().getUuid());

                                StateData newStateData = StateData.NewInstance(newState);

                                elementBase.addStateData(newStateData);

                            }

                            desc.addElement(elementBase);

                        }

                        if (descElement instanceof QuantitativeDataDto){

                            QuantitativeData data = QuantitativeData.NewInstance(feature);

                            Set<StatisticalMeasurementValue> statisticalValues = new HashSet<>();

                            Set<StatisticalMeasurementValueDto> valueDtos = ((QuantitativeDataDto)descElement).getValues();

                            data.getStatisticalValues().clear();

                            for (StatisticalMeasurementValueDto dataDto: valueDtos){

                                //create new statedata

                                StatisticalMeasurementValue newStatisticalMeasurement = StatisticalMeasurementValue.NewInstance(DefinedTermBase.getTermByClassAndUUID(StatisticalMeasure.class, dataDto.getType().getUuid()), dataDto.getValue());

                                statisticalValues.add(newStatisticalMeasurement);

                                data.addStatisticalValue(newStatisticalMeasurement);

                            }

//                            data.getStatisticalValues().addAll(statisticalValues);

                            data = StructuredDescriptionAggregation.handleMissingMinOrMax(data,

                                    MissingMinimumMode.MinToZero, MissingMaximumMode.MaxToMin);

                            desc.addElement(data);

                        }

                        //create new element

                    }else{

                        DescriptionElementBase elementBase = equalUuidsElements.get(0);

                        if (elementBase.isInstanceOf(CategoricalData.class)){

                            CategoricalData data = HibernateProxyHelper.deproxy(elementBase, CategoricalData.class);

                            List<StateData> states = new ArrayList<>(data.getStateData());

                            List<StateDataDto> stateDtos = ((CategoricalDataDto)descElement).getStates();

                            data.getStateData().clear();

                            for (StateDataDto dataDto: stateDtos){

                                List<StateData> equalUuidsStateData = states.stream().filter( e -> e.getUuid().equals(dataDto.getUuid())).collect(Collectors.toList());

//                                if (equalUuidsStateData.size() == 1){

//                                    //do nothing because state already exist

//                                }else if (equalUuidsStateData.isEmpty()){

                                    //create new statedata

                                    State newState = DefinedTermBase.getTermByClassAndUUID(State.class, dataDto.getState().getUuid());

                                    StateData newStateData = StateData.NewInstance(newState);

                                    data.addStateData(newStateData);

//                                }

                            }

                          //delete removed state data

//                            Set<StateData> toRemove = new HashSet<>();

//                            for (StateData stateData:states){

////                                List<StateDataDto> equalUuidsStateData = new ArrayList<>();

////                                for (StateDataDto dto: stateDtos){

////                                    if (dto.getUuid() == stateData.getUuid()){

////                                        equalUuidsStateData.add(dto);

////                                    }

////                                }

//                                List<StateDataDto> equalUuidsStateData = stateDtos.stream().filter( e -> e.getUuid() == stateData.getUuid()).collect(Collectors.toList());

//                                if (equalUuidsStateData.size() == 0){

//                                    toRemove.add(stateData);

//                                }

//                            }

//                            for (StateData remove: toRemove){

//                                data.removeStateData(remove);

//                            }

                        }else if (elementBase.isInstanceOf(QuantitativeData.class)){

                            QuantitativeData data = HibernateProxyHelper.deproxy(elementBase, QuantitativeData.class);

                            Set<StatisticalMeasurementValue> statisticalValues = new HashSet<>();

                            Set<StatisticalMeasurementValueDto> valueDtos = ((QuantitativeDataDto)descElement).getValues();

                            data.getStatisticalValues().clear();

                            for (StatisticalMeasurementValueDto dataDto: valueDtos){

                                //create new statedata

                                StatisticalMeasurementValue newStatisticalMeasurement = StatisticalMeasurementValue.NewInstance(DefinedTermBase.getTermByClassAndUUID(StatisticalMeasure.class, dataDto.getType().getUuid()), dataDto.getValue());

                                statisticalValues.add(newStatisticalMeasurement);

                                data.addStatisticalValue(newStatisticalMeasurement);

                            }

//                            data.getStatisticalValues().addAll(statisticalValues);

                            data = StructuredDescriptionAggregation.handleMissingMinOrMax(data,

                                    MissingMinimumMode.MinToZero, MissingMaximumMode.MaxToMin);

                        }

                    }

                }

                descriptionSpecimenMap.put(describedObjectUuid, desc);

                description = desc;

            }

            try{

                mergeResult = dao.merge(description, true);

                result.addUpdatedObject( mergeResult.getMergedEntity());

//                if (description instanceof SpecimenDescription){

//                    result.addUpdatedObject(mergeResult.getMergedEntity().getDescribedSpecimenOrObservation());

//                }else if (description instanceof TaxonDescription){

//                    result.addUpdatedObject(((TaxonDescription)mergeResult.getMergedEntity()).getTaxon());

//                }else if (description instanceof TaxonNameDescription){

//                    result.addUpdatedObject(((TaxonNameDescription)mergeResult.getMergedEntity()).getTaxonName());

//                }

            }catch(Exception e){

                e.printStackTrace();

            }

        }

        return result;

    }

    /**

     * FIXME Candidate for harmonization

     * descriptionElementService.delete

     */

    @Override

    public UUID deleteDescriptionElement(DescriptionElementBase descriptionElement) {

        return descriptionElementDao.delete(descriptionElement);

    }

    @Override

    public UUID deleteDescriptionElement(UUID descriptionElementUuid) {

        return deleteDescriptionElement(descriptionElementDao.load(descriptionElementUuid));

    }

    @Override

    @Transactional(readOnly = false)

    public DeleteResult deleteDescription(DescriptionBase description) {

        DeleteResult deleteResult = new DeleteResult();

        if (description == null){

            return deleteResult;

        }

        description = load(description.getId(), Arrays.asList("descriptiveDataSets"));

        //avoid lazy init exception

        deleteResult = isDeletable(description.getUuid());

        if (deleteResult.getRelatedObjects() != null && deleteResult.getRelatedObjects().size() == 1){

            Iterator<CdmBase> relObjects = deleteResult.getRelatedObjects().iterator();

            CdmBase next = relObjects.next();

            if (next instanceof CdmLinkSource){

                CdmLinkSource source = (CdmLinkSource)next;

                ICdmTarget target = source.getTarget();

            }

        }

        if (deleteResult.isOk() ){

        	if (description instanceof TaxonDescription){

        		TaxonDescription taxDescription = HibernateProxyHelper.deproxy(description, TaxonDescription.class);

        		Taxon tax = taxDescription.getTaxon();

        		tax.removeDescription(taxDescription, true);

                deleteResult.addUpdatedObject(tax);

        	}

        	else if (HibernateProxyHelper.isInstanceOf(description, SpecimenDescription.class)){

        	    SpecimenDescription specimenDescription = HibernateProxyHelper.deproxy(description, SpecimenDescription.class);

        	    SpecimenOrObservationBase<?> specimen = specimenDescription.getDescribedSpecimenOrObservation();

        	    specimen.removeDescription(specimenDescription);

        	    deleteResult.addUpdatedObject(specimen);

        	}

        	Set<DescriptiveDataSet> descriptiveDataSets = description.getDescriptiveDataSets();

        	for (Iterator<DescriptiveDataSet> iterator = descriptiveDataSets.iterator(); iterator.hasNext();) {

        	    iterator.next().removeDescription(description);

            }

        	dao.delete(description);

        	deleteResult.addDeletedObject(description);

        	deleteResult.setCdmEntity(description);

        }else{

            logger.info(deleteResult.getExceptions().toString());

        }

        return deleteResult;

    }

    @Override

    @Transactional(readOnly = false)

    public DeleteResult deleteDescription(UUID descriptionUuid) {

        return deleteDescription(dao.load(descriptionUuid));

    }

    @Override

    public DeleteResult isDeletable(UUID descriptionUuid){

        DeleteResult result = new DeleteResult();

        DescriptionBase<?> description = this.load(descriptionUuid);

        Set<CdmBase> references = commonService.getReferencingObjectsForDeletion(description);

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

            return result;

        }

        for (CdmBase ref: references){

            String message = null;

            if (description instanceof TaxonDescription && ref instanceof Taxon && ((TaxonDescription)description).getTaxon().equals(ref)){

                continue;

            } else if (description instanceof TaxonNameDescription && ref instanceof TaxonName && ((TaxonNameDescription)description).getTaxonName().equals(ref)){

                continue;

            } else if (description instanceof SpecimenDescription && ref instanceof SpecimenOrObservationBase && ((SpecimenDescription)description).getDescribedSpecimenOrObservation().equals(ref)){

                continue;

            } else if (ref instanceof DescriptionElementBase){

                continue;

            }else {

                message = "The description can't be completely deleted because it is referenced by " + ref.getUserFriendlyTypeName() ;

                result.setAbort();

            }

            if (message != null){

                result.addException(new ReferencedObjectUndeletableException(message));

                result.addRelatedObject(ref);

            }

        }

        return result;

    }

    @Override

    public TermVocabulary<Feature> getFeatureVocabulary(UUID uuid) {

        return vocabularyDao.findByUuid(uuid);

    }

    @Override

    @Deprecated

    public <T extends DescriptionElementBase> List<T> getDescriptionElementsForTaxon(

            Taxon taxon, Set<Feature> features,

            Class<T> type, Integer pageSize,

            Integer pageNumber, List<String> propertyPaths) {

        return listDescriptionElementsForTaxon(taxon, features, type, pageSize, pageNumber, propertyPaths);

    }

    @Override

    public <T extends DescriptionElementBase> List<T> listDescriptionElementsForTaxon(

            Taxon taxon, Set<Feature> features,

            Class<T> type, Integer pageSize,

            Integer pageNumber, List<String> propertyPaths) {

        return dao.getDescriptionElementForTaxon(taxon.getUuid(), features, type, pageSize, pageNumber, propertyPaths);

    }

    @Override

    public <T extends DescriptionElementBase> Pager<T> pageDescriptionElementsForTaxon(

            Taxon taxon, Set<Feature> features,

            Class<T> type, Integer pageSize,

            Integer pageNumber, List<String> propertyPaths) {

        if (logger.isDebugEnabled()){logger.debug(" get count ...");}

        Long count = dao.countDescriptionElementForTaxon(taxon.getUuid(), features, type);

        List<T> descriptionElements;

        if(AbstractPagerImpl.hasResultsInRange(count, pageNumber, pageSize)){ // no point checking again

            if (logger.isDebugEnabled()){logger.debug(" get list ...");}

            descriptionElements = listDescriptionElementsForTaxon(taxon, features, type, pageSize, pageNumber, propertyPaths);

        } else {

            descriptionElements = new ArrayList<T>(0);

        }

        if (logger.isDebugEnabled()){logger.debug(" service - DONE ...");}

        return new DefaultPagerImpl<T>(pageNumber, count, pageSize, descriptionElements);

    }

    @Override

    public String generateNaturalLanguageDescription(TermTree featureTree,

            TaxonDescription description, List<Language> preferredLanguages, String separator) {

        Language lang = preferredLanguages.size() > 0 ? preferredLanguages.get(0) : Language.DEFAULT();