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.io.IOException;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Optional;

import java.util.Set;

import java.util.UUID;

import org.apache.log4j.Logger;

import org.apache.lucene.index.Term;

import org.apache.lucene.sandbox.queries.FuzzyLikeThisQuery;

import org.apache.lucene.search.BooleanClause.Occur;

import org.apache.lucene.search.BooleanQuery;

import org.apache.lucene.search.BooleanQuery.Builder;

import org.apache.lucene.search.TopDocs;

import org.apache.lucene.search.WildcardQuery;

import org.hibernate.criterion.Criterion;

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

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

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

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

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

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

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

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

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

import eu.etaxonomy.cdm.api.service.search.DocumentSearchResult;

import eu.etaxonomy.cdm.api.service.search.ILuceneIndexToolProvider;

import eu.etaxonomy.cdm.api.service.search.ISearchResultBuilder;

import eu.etaxonomy.cdm.api.service.search.LuceneParseException;

import eu.etaxonomy.cdm.api.service.search.LuceneSearch;

import eu.etaxonomy.cdm.api.service.search.QueryFactory;

import eu.etaxonomy.cdm.api.service.search.SearchResult;

import eu.etaxonomy.cdm.api.service.search.SearchResultBuilder;

import eu.etaxonomy.cdm.api.utility.TaxonNamePartsFilter;

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

import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;

import eu.etaxonomy.cdm.model.CdmBaseType;

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

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

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

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

import eu.etaxonomy.cdm.model.common.RelationshipBase.Direction;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import eu.etaxonomy.cdm.persistence.dao.common.ICdmGenericDao;

import eu.etaxonomy.cdm.persistence.dao.common.IOrderedTermVocabularyDao;

import eu.etaxonomy.cdm.persistence.dao.common.IReferencedEntityDao;

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

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

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

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

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

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

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

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

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

import eu.etaxonomy.cdm.strategy.cache.TaggedText;

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

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

@Service

@Transactional(readOnly = true)

public class NameServiceImpl

          extends IdentifiableServiceBase<TaxonName,ITaxonNameDao>

          implements INameService {

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

    @Autowired

    protected ITermVocabularyDao vocabularyDao;

    @Autowired

    protected IOrderedTermVocabularyDao orderedVocabularyDao;

    @Autowired

    @Qualifier("refEntDao")

    protected IReferencedEntityDao<ReferencedEntityBase> referencedEntityDao;

    @Autowired

    private INomenclaturalStatusDao nomStatusDao;

    @Autowired

    private ITypeDesignationDao typeDesignationDao;

    @Autowired

    private IHomotypicalGroupDao homotypicalGroupDao;

    @Autowired

    private ICdmGenericDao genericDao;

    @Autowired

    private ILuceneIndexToolProvider luceneIndexToolProvider;

    /**

     * Constructor

     */

    public NameServiceImpl(){}

//********************* METHODS ****************************************************************//

    @Override

    @Transactional(readOnly = false)

    public DeleteResult delete(UUID nameUUID){

        NameDeletionConfigurator config = new NameDeletionConfigurator();

        DeleteResult result = delete(nameUUID, config);

        return result;

    }

    @Override

    public DeleteResult delete(TaxonName name){

        return delete(name.getUuid());

    }

    @Override

    @Transactional(readOnly = false)

    public DeleteResult delete(TaxonName name, NameDeletionConfigurator config) {

        DeleteResult result = new DeleteResult();

        if (name == null){

            result.setAbort();

            return result;

        }

        try{

            result = this.isDeletable(name, config);

        }catch(Exception e){

            result.addException(e);

            result.setError();

            return result;

        }

        if (result.isOk()){

        //remove references to this name

            removeNameRelationshipsByDeleteConfig(name, config);

           //remove name from homotypical group

            HomotypicalGroup homotypicalGroup = name.getHomotypicalGroup();

            if (homotypicalGroup != null){

                homotypicalGroup.removeTypifiedName(name, false);

            }

             //all type designation relationships are removed as they belong to the name

            deleteTypeDesignation(name, null);

    //      //type designations

    //      if (! name.getTypeDesignations().isEmpty()){

    //          String message = "Name can't be deleted as it has types. Remove types prior to deletion.";

    //          throw new ReferrencedObjectUndeletableException(message);

    //      }

            try{

                dao.delete(name);

                result.addDeletedObject(name);

            }catch(Exception e){

                result.addException(e);

                result.setError();

            }

            return result;

        }

        return result;

    }

    @Override

    @Transactional(readOnly = false)

    public DeleteResult delete(UUID nameUUID, NameDeletionConfigurator config) {

        TaxonName name = dao.load(nameUUID);

        return delete(name, config);

    }

    @Override

    @Transactional

    public DeleteResult deleteTypeDesignation(TaxonName name, TypeDesignationBase typeDesignation){

    	if(typeDesignation != null && typeDesignation .isPersited()){

    		typeDesignation = HibernateProxyHelper.deproxy(referencedEntityDao.load(typeDesignation.getUuid()), TypeDesignationBase.class);

    	}

        DeleteResult result = new DeleteResult();

        if (name == null && typeDesignation == null){

            result.setError();

            return result;

        }else if (name != null && typeDesignation != null){

            removeSingleDesignation(name, typeDesignation);

        }else if (name != null){

            @SuppressWarnings("rawtypes")

            Set<TypeDesignationBase> designationSet = new HashSet<>(name.getTypeDesignations());

            for (TypeDesignationBase<?> desig : designationSet){

                desig = CdmBase.deproxy(desig);

                removeSingleDesignation(name, desig);

            }

        }else if (typeDesignation != null){

            @SuppressWarnings("unchecked")

            Set<TaxonName> nameSet = new HashSet<>(typeDesignation.getTypifiedNames());

            for (TaxonName singleName : nameSet){

                singleName = CdmBase.deproxy(singleName);

                removeSingleDesignation(singleName, typeDesignation);

            }

        }

        result.addDeletedObject(typeDesignation);

        result.addUpdatedObject(name);

        return result;

    }

    @Override

    @Transactional(readOnly = false)

    public DeleteResult deleteTypeDesignation(UUID nameUuid, UUID typeDesignationUuid){

        TaxonName nameBase = load(nameUuid);

        TypeDesignationBase<?> typeDesignation = HibernateProxyHelper.deproxy(referencedEntityDao.load(typeDesignationUuid), TypeDesignationBase.class);

        return deleteTypeDesignation(nameBase, typeDesignation);

    }

    /**

     * @param name

     * @param typeDesignation

     */

    @Transactional

    private void removeSingleDesignation(TaxonName name, TypeDesignationBase typeDesignation) {

        name.removeTypeDesignation(typeDesignation);

        if (typeDesignation.getTypifiedNames().isEmpty()){

            typeDesignation.removeType();

            if (!typeDesignation.getRegistrations().isEmpty()){

                for(Object reg: typeDesignation.getRegistrations()){

                    if (reg instanceof Registration){

                        ((Registration)reg).removeTypeDesignation(typeDesignation);

                    }

                }

            }

            typeDesignationDao.delete(typeDesignation);

        }

    }

    /**

     * @param name

     * @param config

     */

    private void removeNameRelationshipsByDeleteConfig(TaxonName name, NameDeletionConfigurator config) {

        try {

            if (config.isRemoveAllNameRelationships()){

                Set<NameRelationship> rels = getModifiableSet(name.getNameRelations());

                for (NameRelationship rel : rels){

                    name.removeNameRelationship(rel);

                }

            }else{

                //relations to this name

                Set<NameRelationship> rels = getModifiableSet(name.getRelationsToThisName());

                for (NameRelationship rel : rels){

                    if (config.isIgnoreHasBasionym() && NameRelationshipType.BASIONYM().equals(rel.getType() )){

                            name.removeNameRelationship(rel);

                    }else if (config.isIgnoreHasReplacedSynonym() && NameRelationshipType.REPLACED_SYNONYM().equals(rel.getType())){

                        name.removeNameRelationship(rel);

                    }

                }

                //relations from this name

                rels = getModifiableSet(name.getRelationsFromThisName());

                for (NameRelationship rel : rels){

                    if (config.isIgnoreIsBasionymFor() && NameRelationshipType.BASIONYM().equals(rel.getType())  ){

                        name.removeNameRelationship(rel);

                    }else if (config.isIgnoreIsReplacedSynonymFor() && NameRelationshipType.REPLACED_SYNONYM().equals(rel.getType())){

                        name.removeNameRelationship(rel);

                    }

                }

            }

        } catch (Exception e) {

            throw new RuntimeException(e);

        }

    }

    /**

     * @param name

     * @return

     */

    private Set<NameRelationship> getModifiableSet(Set<NameRelationship> relations) {

        Set<NameRelationship> rels = new HashSet<NameRelationship>();

        for (NameRelationship rel : relations){

            rels.add(rel);

        }

        return rels;

    }

//********************* METHODS ****************************************************************//

    /**

     * TODO candidate for harmonization

     * new name findByName

     */

    @Override

    @Deprecated

    public List<TaxonName> getNamesByNameCache(String nameCache){

        boolean includeAuthors = false;

        List result = dao.findByName(includeAuthors, nameCache, MatchMode.EXACT, null, null, null, null);

        return result;

    }

    /**

     * TODO candidate for harmonization

     * new name saveHomotypicalGroups

     *

     * findByTitle

     */

    @Override

    public List<TaxonName> findNamesByTitleCache(String titleCache, MatchMode matchMode, List<String> propertyPaths){

        List result = dao.findByTitle(titleCache, matchMode, null, null, null, propertyPaths);

        return result;

    }

    /**

     * TODO candidate for harmonization

     * new name saveHomotypicalGroups

     *

     * findByTitle

     */

    @Override

    public List<TaxonName> findNamesByNameCache(String nameCache, MatchMode matchMode, List<String> propertyPaths){

        List<TaxonName> result = dao.findByName(false, nameCache, matchMode, null, null, null , propertyPaths);

        return result;

    }

    @Override

    public Pager<TaxonNameParts> findTaxonNameParts(Optional<String> genusOrUninomial,

            Optional<String> infraGenericEpithet, Optional<String> specificEpithet,

            Optional<String> infraSpecificEpithet, Rank rank, Set<UUID> excludedNamesUuids,

            Integer pageSize, Integer pageIndex, List<OrderHint> orderHints) {

        long count = dao.countTaxonNameParts(genusOrUninomial, infraGenericEpithet, specificEpithet, infraGenericEpithet, rank, excludedNamesUuids);

        List<TaxonNameParts> results;

        if(AbstractPagerImpl.hasResultsInRange(count, pageIndex, pageSize)){

            results = dao.findTaxonNameParts(genusOrUninomial, infraGenericEpithet, specificEpithet, infraSpecificEpithet,

                    rank, excludedNamesUuids,

                    pageSize, pageIndex, orderHints);

        } else {

            results = new ArrayList<>();

        }

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

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public Pager<TaxonNameParts> findTaxonNameParts(TaxonNamePartsFilter filter, String namePartQueryString,

            Integer pageSize, Integer pageIndex, List<OrderHint> orderHints) {

        return findTaxonNameParts(

                filter.uninomialQueryString(namePartQueryString),

                filter.infraGenericEpithet(namePartQueryString),

                filter.specificEpithet(namePartQueryString),

                filter.infraspecificEpithet(namePartQueryString),

                filter.getRank(),

                filter.getExludedNamesUuids(),

                pageSize, pageIndex, orderHints);

    }

    /**

     * TODO candidate for harmonization

     * new name saveHomotypicalGroups

     */

    @Override

    @Transactional(readOnly = false)

    public Map<UUID, HomotypicalGroup> saveAllHomotypicalGroups(Collection<HomotypicalGroup> homotypicalGroups){

        return homotypicalGroupDao.saveAll(homotypicalGroups);

    }

    /**

     * TODO candidate for harmonization

     * new name saveTypeDesignations

     */

    @Override

    @Transactional(readOnly = false)

    public Map<UUID, TypeDesignationBase> saveTypeDesignationAll(Collection<TypeDesignationBase> typeDesignationCollection){

        return typeDesignationDao.saveAll(typeDesignationCollection);

    }

    /**

     * TODO candidate for harmonization

     * new name saveReferencedEntities

     */

    @Override

    @Transactional(readOnly = false)

    public Map<UUID, ReferencedEntityBase> saveReferencedEntitiesAll(Collection<ReferencedEntityBase> referencedEntityCollection){

        return referencedEntityDao.saveAll(referencedEntityCollection);

    }

    /**

     * TODO candidate for harmonization

     * new name getNomenclaturalStatus

     */

    @Override

    public List<NomenclaturalStatus> getAllNomenclaturalStatus(int limit, int start){

        return nomStatusDao.list(limit, start);

    }

    /**

     * TODO candidate for harmonization

     * new name getTypeDesignations

     */

    @Override

    public List<TypeDesignationBase> getAllTypeDesignations(int limit, int start){

        return typeDesignationDao.getAllTypeDesignations(limit, start);

    }

    @Override

    public TypeDesignationBase loadTypeDesignation(int id, List<String> propertyPaths){

        return typeDesignationDao.load(id, propertyPaths);

    }

    @Override

    public TypeDesignationBase loadTypeDesignation(UUID uuid, List<String> propertyPaths){

        return typeDesignationDao.load(uuid, propertyPaths);

    }

    /**

     * FIXME Candidate for harmonization

     * homotypicalGroupService.list

     */

    @Override

    public List<HomotypicalGroup> getAllHomotypicalGroups(int limit, int start){

        return homotypicalGroupDao.list(limit, start);

    }

    /**

     * FIXME Candidate for harmonization

     * remove

     */

    @Override

    @Deprecated

    public List<RelationshipBase> getAllRelationships(int limit, int start){

        return dao.getAllRelationships(limit, start);

    }

    @Override

    @Autowired

    protected void setDao(ITaxonNameDao dao) {

        this.dao = dao;

    }

    @Override

    public Pager<HybridRelationship> getHybridNames(INonViralName name,	HybridRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {

        Integer numberOfResults = dao.countHybridNames(name, type);

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

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

            results = dao.getHybridNames(name, type, pageSize, pageNumber,orderHints,propertyPaths);

        }

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

    }

    @Override

    public List<NameRelationship> listNameRelationships(TaxonName name,	Direction direction, NameRelationshipType type, Integer pageSize,

            Integer pageNumber, List<OrderHint> orderHints,	List<String> propertyPaths) {

        Integer numberOfResults = dao.countNameRelationships(name, direction, type);

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

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

            results = dao.getNameRelationships(name, direction, type, pageSize,	pageNumber, orderHints, propertyPaths);

        }

        return results;

    }

    protected LuceneSearch prepareFindByFuzzyNameSearch(Class<? extends CdmBase> clazz,

            INonViralName nvn,

            float accuracy,

            int maxNoOfResults,

            List<Language> languages,

            boolean highlightFragments) {

        String similarity = Float.toString(accuracy);

        String searchSuffix = "~" + similarity;

        Builder finalQueryBuilder = new Builder();

        finalQueryBuilder.setDisableCoord(false);

        Builder textQueryBuilder = new Builder();

        textQueryBuilder.setDisableCoord(false);

        LuceneSearch luceneSearch = new LuceneSearch(luceneIndexToolProvider, TaxonName.class);

        QueryFactory queryFactory = luceneIndexToolProvider.newQueryFactoryFor(TaxonName.class);

//    	SortField[] sortFields = new  SortField[]{SortField.FIELD_SCORE, new SortField("titleCache__sort", SortField.STRING,  false)};

//    	luceneSearch.setSortFields(sortFields);

        // ---- search criteria

        luceneSearch.setCdmTypRestriction(clazz);

        FuzzyLikeThisQuery fltq = new FuzzyLikeThisQuery(maxNoOfResults, luceneSearch.getAnalyzer());

        if(nvn.getGenusOrUninomial() != null && !nvn.getGenusOrUninomial().equals("")) {

            fltq.addTerms(nvn.getGenusOrUninomial().toLowerCase(), "genusOrUninomial", accuracy, 3);

        } else {

            //textQuery.add(new RegexQuery (new Term ("genusOrUninomial", "^[a-zA-Z]*")), Occur.MUST_NOT);

            textQueryBuilder.add(queryFactory.newTermQuery("genusOrUninomial", "_null_", false), Occur.MUST);

        }

        if(nvn.getInfraGenericEpithet() != null && !nvn.getInfraGenericEpithet().equals("")){

            fltq.addTerms(nvn.getInfraGenericEpithet().toLowerCase(), "infraGenericEpithet", accuracy, 3);

        } else {

            //textQuery.add(new RegexQuery (new Term ("infraGenericEpithet", "^[a-zA-Z]*")), Occur.MUST_NOT);

            textQueryBuilder.add(queryFactory.newTermQuery("infraGenericEpithet", "_null_", false), Occur.MUST);

        }

        if(nvn.getSpecificEpithet() != null && !nvn.getSpecificEpithet().equals("")){

            fltq.addTerms(nvn.getSpecificEpithet().toLowerCase(), "specificEpithet", accuracy, 3);

        } else {

            //textQuery.add(new RegexQuery (new Term ("specificEpithet", "^[a-zA-Z]*")), Occur.MUST_NOT);

            textQueryBuilder.add(queryFactory.newTermQuery("specificEpithet", "_null_", false), Occur.MUST);

        }

        if(nvn.getInfraSpecificEpithet() != null && !nvn.getInfraSpecificEpithet().equals("")){

            fltq.addTerms(nvn.getInfraSpecificEpithet().toLowerCase(), "infraSpecificEpithet", accuracy, 3);

        } else {

            //textQuery.add(new RegexQuery (new Term ("infraSpecificEpithet", "^[a-zA-Z]*")), Occur.MUST_NOT);

            textQueryBuilder.add(queryFactory.newTermQuery("infraSpecificEpithet", "_null_", false), Occur.MUST);

        }

        if(nvn.getAuthorshipCache() != null && !nvn.getAuthorshipCache().equals("")){

            fltq.addTerms(nvn.getAuthorshipCache().toLowerCase(), "authorshipCache", accuracy, 3);

        } else {

            //textQuery.add(new RegexQuery (new Term ("authorshipCache", "^[a-zA-Z]*")), Occur.MUST_NOT);

        }

        textQueryBuilder.add(fltq, Occur.MUST);

        BooleanQuery textQuery = textQueryBuilder.build();

        finalQueryBuilder.add(textQuery, Occur.MUST);

        luceneSearch.setQuery(finalQueryBuilder.build());

        if(highlightFragments){

            luceneSearch.setHighlightFields(queryFactory.getTextFieldNamesAsArray());

        }

        return luceneSearch;

    }

    protected LuceneSearch prepareFindByFuzzyNameCacheSearch(Class<? extends CdmBase> clazz,

            String name,

            float accuracy,

            int maxNoOfResults,

            List<Language> languages,

            boolean highlightFragments) {

        LuceneSearch luceneSearch = new LuceneSearch(luceneIndexToolProvider, TaxonName.class);

        QueryFactory queryFactory = luceneIndexToolProvider.newQueryFactoryFor(TaxonName.class);

//    	SortField[] sortFields = new  SortField[]{SortField.FIELD_SCORE, new SortField("titleCache__sort", SortField.STRING,  false)};

//    	luceneSearch.setSortFields(sortFields);

        // ---- search criteria

        luceneSearch.setCdmTypRestriction(clazz);

        FuzzyLikeThisQuery fltq = new FuzzyLikeThisQuery(maxNoOfResults, luceneSearch.getAnalyzer());

        fltq.addTerms(name, "nameCache", accuracy, 3);

         BooleanQuery finalQuery = new BooleanQuery(false);

         finalQuery.add(fltq, Occur.MUST);

        luceneSearch.setQuery(finalQuery);

        if(highlightFragments){

            luceneSearch.setHighlightFields(queryFactory.getTextFieldNamesAsArray());

        }

        return luceneSearch;

    }

    protected LuceneSearch prepareFindByExactNameSearch(Class<? extends CdmBase> clazz,

            String name,

            boolean wildcard,

            List<Language> languages,

            boolean highlightFragments) {

        Builder textQueryBuilder = new Builder();

        LuceneSearch luceneSearch = new LuceneSearch(luceneIndexToolProvider, TaxonName.class);

        QueryFactory queryFactory = luceneIndexToolProvider.newQueryFactoryFor(TaxonName.class);

//    	SortField[] sortFields = new  SortField[]{SortField.FIELD_SCORE, new SortField("titleCache__sort", SortField.STRING,  false)};

//    	luceneSearch.setSortFields(sortFields);

        // ---- search criteria

        luceneSearch.setCdmTypRestriction(clazz);

        if(name != null && !name.equals("")) {

            if(wildcard) {

                textQueryBuilder.add(new WildcardQuery(new Term("nameCache", name + "*")), Occur.MUST);

            } else {

                textQueryBuilder.add(queryFactory.newTermQuery("nameCache", name, false), Occur.MUST);

            }

        }

        luceneSearch.setQuery(textQueryBuilder.build());

        if(highlightFragments){

            luceneSearch.setHighlightFields(queryFactory.getTextFieldNamesAsArray());

        }

        return luceneSearch;

    }

    @Override

    public List<SearchResult<TaxonName>> findByNameFuzzySearch(

            String name,

            float accuracy,

            List<Language> languages,

            boolean highlightFragments,

            List<String> propertyPaths,

            int maxNoOfResults) throws IOException, LuceneParseException {

        logger.info("Name to fuzzy search for : " + name);

        // parse the input name

        NonViralNameParserImpl parser = new NonViralNameParserImpl();

        INonViralName nvn = parser.parseFullName(name);

        if(name != null && !name.equals("") && nvn == null) {

            throw new LuceneParseException("Could not parse name " + name);

        }

        LuceneSearch luceneSearch = prepareFindByFuzzyNameSearch(null, nvn, accuracy, maxNoOfResults, languages, highlightFragments);

        // --- execute search

        TopDocs topDocs = luceneSearch.executeSearch(maxNoOfResults);

        Map<CdmBaseType, String> idFieldMap = new HashMap<CdmBaseType, String>();

        idFieldMap.put(CdmBaseType.NONVIRALNAME, "id");

        // --- initialize taxa, highlight matches ....

        ISearchResultBuilder searchResultBuilder = new SearchResultBuilder(luceneSearch, luceneSearch.getQuery());

        @SuppressWarnings("rawtypes")

        List<SearchResult<TaxonName>> searchResults = searchResultBuilder.createResultSet(

                topDocs, luceneSearch.getHighlightFields(), dao, idFieldMap, propertyPaths);

        return searchResults;

    }

    @Override

    public List<DocumentSearchResult> findByNameFuzzySearch(

            String name,

            float accuracy,

            List<Language> languages,

            boolean highlightFragments,

            int maxNoOfResults) throws IOException, LuceneParseException {

        logger.info("Name to fuzzy search for : " + name);

        // parse the input name

        NonViralNameParserImpl parser = new NonViralNameParserImpl();

        INonViralName nvn = parser.parseFullName(name);

        if(name != null && !name.equals("") && nvn == null) {

            throw new LuceneParseException("Could not parse name " + name);

        }

        LuceneSearch luceneSearch = prepareFindByFuzzyNameSearch(null, nvn, accuracy, maxNoOfResults, languages, highlightFragments);

        // --- execute search

        TopDocs topDocs = luceneSearch.executeSearch(maxNoOfResults);

        Map<CdmBaseType, String> idFieldMap = new HashMap<CdmBaseType, String>();

        // --- initialize taxa, highlight matches ....

        ISearchResultBuilder searchResultBuilder = new SearchResultBuilder(luceneSearch, luceneSearch.getQuery());

        @SuppressWarnings("rawtypes")

        List<DocumentSearchResult> searchResults = searchResultBuilder.createResultSet(topDocs, luceneSearch.getHighlightFields());

        return searchResults;

    }

    @Override

    public List<DocumentSearchResult> findByFuzzyNameCacheSearch(

            String name,

            float accuracy,

            List<Language> languages,

            boolean highlightFragments,

            int maxNoOfResults) throws IOException, LuceneParseException {

        logger.info("Name to fuzzy search for : " + name);

        LuceneSearch luceneSearch = prepareFindByFuzzyNameCacheSearch(null, name, accuracy, maxNoOfResults, languages, highlightFragments);

        // --- execute search

        TopDocs topDocs = luceneSearch.executeSearch(maxNoOfResults);

        Map<CdmBaseType, String> idFieldMap = new HashMap<CdmBaseType, String>();

        // --- initialize taxa, highlight matches ....

        ISearchResultBuilder searchResultBuilder = new SearchResultBuilder(luceneSearch, luceneSearch.getQuery());

        @SuppressWarnings("rawtypes")

        List<DocumentSearchResult> searchResults = searchResultBuilder.createResultSet(topDocs, luceneSearch.getHighlightFields());

        return searchResults;

    }

    @Override

    public List<DocumentSearchResult> findByNameExactSearch(

            String name,

            boolean wildcard,

            List<Language> languages,

            boolean highlightFragments,

            int maxNoOfResults) throws IOException, LuceneParseException {

        logger.info("Name to exact search for : " + name);

        LuceneSearch luceneSearch = prepareFindByExactNameSearch(null, name, wildcard, languages, highlightFragments);

        // --- execute search

        TopDocs topDocs = luceneSearch.executeSearch(maxNoOfResults);

        Map<CdmBaseType, String> idFieldMap = new HashMap<CdmBaseType, String>();

        // --- initialize taxa, highlight matches ....

        ISearchResultBuilder searchResultBuilder = new SearchResultBuilder(luceneSearch, luceneSearch.getQuery());

        @SuppressWarnings("rawtypes")

        List<DocumentSearchResult> searchResults = searchResultBuilder.createResultSet(topDocs, luceneSearch.getHighlightFields());

        return searchResults;

    }

    @Override

    public Pager<NameRelationship> pageNameRelationships(TaxonName name, Direction direction, NameRelationshipType type, Integer pageSize,

            Integer pageNumber, List<OrderHint> orderHints,	List<String> propertyPaths) {

        List<NameRelationship> results = listNameRelationships(name, direction, type, pageSize, pageNumber, orderHints, propertyPaths);

        return new DefaultPagerImpl<NameRelationship>(pageNumber, results.size(), pageSize, results);

    }

    @Override

    public List<NameRelationship> listFromNameRelationships(TaxonName name, NameRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {

        return listNameRelationships(name, Direction.relatedFrom, type, pageSize, pageNumber, orderHints, propertyPaths);

    }

    @Override

    public Pager<NameRelationship> pageFromNameRelationships(TaxonName name, NameRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {

        List<NameRelationship> results = listNameRelationships(name, Direction.relatedFrom, type, pageSize, pageNumber, orderHints, propertyPaths);

        return new DefaultPagerImpl<NameRelationship>(pageNumber, results.size(), pageSize, results);

    }

    @Override

    public List<NameRelationship> listToNameRelationships(TaxonName name, NameRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {

        return listNameRelationships(name, Direction.relatedTo, type, pageSize, pageNumber, orderHints, propertyPaths);

    }

    @Override

    public Pager<NameRelationship> pageToNameRelationships(TaxonName name, NameRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {

        List<NameRelationship> results = listNameRelationships(name, Direction.relatedTo, type, pageSize, pageNumber, orderHints, propertyPaths);

        return new DefaultPagerImpl<NameRelationship>(pageNumber, results.size(), pageSize, results);

    }

    @Override

    public Pager<TypeDesignationBase> getTypeDesignations(TaxonName name, SpecimenTypeDesignationStatus status,

            Integer pageSize, Integer pageNumber) {

        return getTypeDesignations(name, status, pageSize, pageNumber, null);

    }

    @Override

    public Pager<TypeDesignationBase> getTypeDesignations(TaxonName name, SpecimenTypeDesignationStatus status,

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

        long numberOfResults = dao.countTypeDesignations(name, status);

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

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

            results = dao.getTypeDesignations(name, null, status, pageSize, pageNumber, propertyPaths);