EDIT

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

    @Override

    public TaxonBase load(UUID uuid, boolean includeUnpublished, List<String> propertyPaths) {

        return dao.load(uuid, includeUnpublished, propertyPaths);

            newTaxon.removeTaxonRelation(taxonRelationship);

        }

        for(TaxonRelationship taxonRelationship : acceptedTaxon.getTaxonRelations()){

            Taxon fromTaxon = HibernateProxyHelper.deproxy(taxonRelationship.getFromTaxon());

            Taxon toTaxon = HibernateProxyHelper.deproxy(taxonRelationship.getToTaxon());

            taxonRelationship.setFromTaxon(null);

        }

        //Move descriptions to new taxon

        List<TaxonDescription> descriptions = new ArrayList<TaxonDescription>( newTaxon.getDescriptions()); //to avoid concurrent modification errors (newAcceptedTaxon.addDescription() modifies also oldtaxon.descritpions())

        for(TaxonDescription description : descriptions){

//            //oldTaxon.removeDescription(description, false);

 //           newTaxon.addDescription(description);

        }

        for (TaxonNode node: nodes){

            node = HibernateProxyHelper.deproxy(node, TaxonNode.class);

            TaxonNode parent = node.getParent();

        }

        result.includeResult(deleteResult);

		return result;

    }

    @Override

    @Transactional(readOnly = false)

    public UpdateResult changeSynonymToAcceptedTaxon(Synonym synonym, Taxon acceptedTaxon, boolean deleteSynonym) {

        return result;

    }

    @Override

    @Transactional(readOnly = false)

    public UpdateResult changeSynonymToRelatedTaxon(UUID synonymUuid,

            SynonymType relType = isHomotypicToTaxon? SynonymType.HOMOTYPIC_SYNONYM_OF() : SynonymType.HETEROTYPIC_SYNONYM_OF();

            targetTaxon.addSynonym(synonym, relType);

        }

    }

    @Override

        this.dao = dao;

    }

    @Override

    public <T extends TaxonBase> Pager<T> findTaxaByName(Class<T> clazz, String uninomial,	String infragenericEpithet, String specificEpithet,

            String infraspecificEpithet, String authorshipCache, Rank rank, Integer pageSize,Integer pageNumber, List<String> propertyPaths) {

        return relatedTaxa;

    }

    /**

     * Recursively collect related taxa for the given <code>taxon</code> . The returned list will also include the

     *  <code>taxon</code> supplied as parameter.

        taxon = (Taxon)dao.load(taxon.getUuid(), propertyPaths);

        HomotypicGroupTaxonComparator comparator = new HomotypicGroupTaxonComparator(taxon);

        //homotypic

        result.add(taxon.getHomotypicSynonymsByHomotypicGroup(comparator));

        }

        return result;

    }

    @Override

    @Override

    public Pager<IdentifiableEntity> findTaxaAndNames(IFindTaxaAndNamesConfigurator configurator) {

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

        long numberOfResults = 0; // overall number of results (as opposed to number of results per page)

        List<TaxonBase> taxa = null;

                    configurator.getMatchMode(), configurator.getNamedAreas(), configurator.isIncludeUnpublished(),

                    configurator.getOrder(), configurator.getPageSize(), configurator.getPageNumber(), propertyPath);

            }

        if (logger.isDebugEnabled()) { logger.debug(numberTaxaResults + " matching taxa counted"); }

        if(includeOccurrences != null && includeOccurrences) {

            logger.trace("listMedia() - includeOccurrences");

            Set<SpecimenOrObservationBase> specimensOrObservations = new HashSet<>();

            // --- Specimens

            for (Taxon t : taxa) {

            }

        }

        logger.trace("listMedia() - initialize");

        beanInitializer.initializeAll(taxonMedia, propertyPath);

        return this.dao.countSynonyms(onlyAttachedToTaxon);

    }

    @Override

    @Transactional(readOnly=false)

    public DeleteResult deleteTaxon(UUID taxonUUID, TaxonDeletionConfigurator config, UUID classificationUuid)  {

                        break;

                    }

                    removeDescriptions.add(desc);

                }

                if (result.isOk()){

                    for (TaxonDescription desc: removeDescriptions){

                }

            }

                    }

                            }

                        }

                    }

                    }

                }

             }

       }

       return result;

    }

    @Override

    @Transactional(readOnly = false)

    public DeleteResult deleteSynonym(UUID synonymUuid, SynonymDeletionConfigurator config) {

        return deleteSynonym((Synonym)dao.load(synonymUuid), config);

    }

    @Override

    @Transactional(readOnly = false)

    public DeleteResult deleteSynonym(Synonym synonym, SynonymDeletionConfigurator config) {

                        result.addDeletedObject(name);

                    }

            }

        }

        return result;

    }

        return this.dao.findIdenticalNames(sourceRefUuids, propertyPaths);

    }

    @Override

    public Taxon findBestMatchingTaxon(String taxonName) {

        MatchingTaxonConfigurator config = MatchingTaxonConfigurator.NewInstance();

                        countEqualCandidates = 1;

                        continue;

                    }

                }else{  //not Taxon.class

                    continue;

                }

                }

            }

            // 2. search for synonyms

            if (config.isIncludeSynonyms()){

                List<TaxonBase> synonymList = dao.findByNameTitleCache(false, true, config.isIncludeUnpublished(),

        // ---  initialize taxa, thighlight matches ....

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

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

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

        return new DefaultPagerImpl<>(pageNumber, totalHits, pageSize, searchResults);

    }

    @Transactional(readOnly = true)

    @Override

    public <S extends TaxonBase> Pager<S> findByTitleWithRestrictions(Class<S> clazz, String queryString, MatchMode matchmode, List<Restriction<?>> restrictions, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {

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

    }

    @Transactional(readOnly = true)

    @Override

    public <S extends TaxonBase> Pager<S> findByTitle(Class<S> clazz, String queryString,MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {

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

    }

    @Override

    public Pager<SearchResult<TaxonBase>> findByDistribution(List<NamedArea> areaFilter, List<PresenceAbsenceTerm> statusFilter,

            Classification classification, TaxonNode subtree,

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

//        SortField[] sortFields = new SortField[]{new SortField(NomenclaturalSortOrderBrigde.NAME_SORT_FIELD_NAME, SortField.STRING, false)};

        boolean addDistributionFilter = namedAreas != null && namedAreas.size() > 0;

        List<LuceneSearch> luceneSearches = new ArrayList<>();

            }

        }

        // search by pro parte synonyms

        if(searchModes.contains(TaxaAndNamesSearchMode.doSynonyms)) {

            //TODO merge with misapplied name search once #7487 is fixed

            }

        }//end pro parte synonyms

        LuceneMultiSearch multiSearch = new LuceneMultiSearch(luceneIndexToolProvider,

                luceneSearches.toArray(new LuceneSearch[luceneSearches.size()]));

        if(addDistributionFilter){

            // B)

            Classification classification, TaxonNode subtree, List<Feature> features, List<Language> languages,

            boolean highlightFragments, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) throws IOException, LuceneParseException {

        LuceneSearch luceneSearch = prepareByDescriptionElementFullTextSearch(clazz, queryString, classification, subtree, features, languages, highlightFragments);

        // --- execute search

        int totalHits = topDocsResultSet != null ? topDocsResultSet.totalGroupCount : 0;

        return new DefaultPagerImpl<>(pageNumber, Long.valueOf(totalHits), pageSize, searchResults);

    }

    @Override

    public Pager<SearchResult<TaxonBase>> findByEverythingFullText(String queryString,

            Classification classification, TaxonNode subtree, boolean includeUnpublished, List<Language> languages, boolean highlightFragments,

        int totalHits = topDocsResultSet != null ? topDocsResultSet.totalGroupCount : 0;

        return new DefaultPagerImpl<>(pageNumber, Long.valueOf(totalHits), pageSize, searchResults);

    }

    /**

     * @param clazz

     * @param queryString

    @Override

    public List<Synonym> createInferredSynonyms(Taxon taxon, Classification classification, SynonymType type, boolean doWithMisappliedNames){

        List <Synonym> inferredSynonyms = new ArrayList<>();

        List<Synonym> inferredSynonymsToBeRemoved = new ArrayList<>();

                            }

                            if (!taxonNames.isEmpty()){

                                    }

                                }

                            }

                                inferredSynonyms.add(inferredGenus);

                                zooHashMap.put(inferredGenus.getName().getUuid(), inferredGenus.getName());

                            }

                                }

                            }

                            }

                                // Set the sourceReference

                                // Determine the idInSource

                                String synParentGenus = parentSynZooName.getGenusOrUninomial();

                                String synParentInfragenericName = null;

                                String synParentSpecificEpithet = null;

                                    synParentSpecificEpithet = parentSynZooName.getSpecificEpithet();

                                }

                                            synParentGenus,

                                            synParentInfragenericName,

                                    taxon.addSynonym(potentialCombination, SynonymType.POTENTIAL_COMBINATION_OF());

                                    inferredSynonyms.add(potentialCombination);

                                     taxonNames.add(potentialCombination.getName().getNameCache());

                                }

                            }

                                    }

                                    }

                                }

                            }

                        }

                    }else {

                        logger.info("The synonym type is not defined.");

                    }

                }

            }

        }

        return inferredSynonyms;

            inferredSynName.setInfraGenericEpithet(synParentInfragenericName);

        }

        potentialCombination = Synonym.NewInstance(inferredSynName, null);

        // Set the sourceReference

        synName = syn.getName();

        IZoologicalName synZooName = getZoologicalName(synName.getUuid(), zooHashMap);

        String synSpeciesEpithetName = synZooName.getSpecificEpithet();

            synonymsEpithet.add(synSpeciesEpithetName);

        }*/

        inferredSynName = TaxonNameFactory.NewZoologicalInstance(taxon.getName().getRank());

        //TODO:differ between parent is genus and taxon is species, parent is subgenus and taxon is species, parent is species and taxon is subspecies and parent is genus and taxon is subgenus...

        inferredSynName.setGenusOrUninomial(genusOfTaxon);

        if (zooParentName.isInfraGeneric()){

            inferredSynName.setInfraGenericEpithet(zooParentName.getInfraGenericEpithet());

            inferredSynName.setInfraSpecificEpithet(synZooName.getInfraGenericEpithet());

        }

        inferredGenus = Synonym.NewInstance(inferredSynName, null);

        // Set the sourceReference

            synSpecificEpithet = zooSynName.getSpecificEpithet();

        }

            synonymsGenus.put(synGenusName, idInSource);

        }*/

        inferredSynName.addSource(originalSource);

        taxon.addSynonym(inferredEpithet, SynonymType.INFERRED_EPITHET_OF());

        return inferredEpithet;

            logger.warn("No idInSource for TaxonBase " + taxonBase.getUuid() + " - " + taxonBase.getTitleCache());

        }

        return idInSource;

    }

    /**

     * Returns the citation for a given Synonym.

     * @param syn

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

        if (taxonBase instanceof Taxon){

            TaxonDeletionConfigurator taxonConfig = (TaxonDeletionConfigurator) config;

            propertyPaths.add("taxonNodes");

            Taxon taxon = (Taxon)load(taxonBaseUuid, propertyPaths);

        return result;

    }

    private DeleteResult isDeletableForTaxon(Set<CdmBase> references, TaxonDeletionConfigurator config){

        String message = null;

        DeleteResult result = new DeleteResult();

                   message = "Taxon can't be deleted as it is used in an identification key. Remove from identification key prior to deleting this taxon";

                }

               /* //PolytomousKeyNode

                if (referencingObject.isInstanceOf(PolytomousKeyNode.class)){

                    String message = "Taxon" + taxon.getTitleCache() + " can't be deleted as it is used in polytomous key node";

    @Override

    public List<TaxonBase> findTaxaByName(MatchingTaxonConfigurator config){

        List<TaxonBase> taxonList = dao.getTaxaByName(true, config.isIncludeSynonyms(), false, false, false,

                config.getTaxonNameTitle(), null, null, MatchMode.EXACT, null, config.isIncludeSynonyms(), null, 0, 0, config.getPropertyPath());

        return taxonList;

		return this.swapSynonymAndAcceptedTaxon(syn, taxon, setNameInSource);

	}

    @Override

    public TaxonRelationshipsDTO listTaxonRelationships(UUID taxonUuid, Set<TaxonRelationshipType> directTypes,

            Set<TaxonRelationshipType> inversTypes,

            return dto;

        }

    }

}