EDIT

import org.apache.lucene.search.BooleanFilter;

import org.apache.lucene.search.DocIdSet;

import org.apache.lucene.search.QueryWrapperFilter;

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

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

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

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

    @Autowired

    private ILuceneIndexToolProvider luceneIndexToolProvider;

    public Pager<TaxonBase> findTaxaByName(Class<? extends TaxonBase> clazz,

            String uninomial,	String infragenericEpithet, String specificEpithet,

            String infraspecificEpithet, Rank rank, Integer pageSize,Integer pageNumber) {

    @Override

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

            Classification classification,

            Integer pageSize, Integer pageNumber,

            List<OrderHint> orderHints, List<String> propertyPaths) throws IOException, ParseException {

        LuceneSearch luceneSearch = prepareByDistributionSearch(areaFilter, statusFilter, classification);

        // --- execute search

        TopGroupsWithMaxScore topDocsResultSet = luceneSearch.executeSearch(pageSize, pageNumber);

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

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

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

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

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

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

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

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

    }

        LuceneSearch luceneSearch = new LuceneSearch(luceneIndexToolProvider, GroupByTaxonClassBridge.GROUPBY_TAXON_FIELD, TaxonBase.class);

        QueryFactory taxonBaseQueryFactory = luceneIndexToolProvider.newQueryFactoryFor(TaxonBase.class);

        luceneSearch.setCdmTypRestriction(clazz);

        textQuery.add(taxonBaseQueryFactory.newTermQuery("titleCache", queryString), Occur.SHOULD);

        textQuery.add(taxonBaseQueryFactory.newDefinedTermQuery("name.rank", queryString, languages), Occur.SHOULD);

            finalQuery.add(taxonBaseQueryFactory.newEntityIdQuery("taxonNodes.classification.id", classification), Occur.MUST);

            luceneSearch.setHighlightFields(taxonBaseQueryFactory.getTextFieldNamesAsArray());

     * @throws IOException

            boolean highlightFragments) throws IOException {

        String fromField;

            fromField = "relatedFrom.id";

            fromField = "relatedTo.id";

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

        QueryFactory taxonBaseQueryFactory = luceneIndexToolProvider.newQueryFactoryFor(TaxonBase.class);

        joinFromQuery.add(taxonBaseQueryFactory.newTermQuery(queryTermField, queryString), Occur.MUST);

        joinFromQuery.add(taxonBaseQueryFactory.newEntityIdQuery("type.id", edge.getTaxonRelationshipType()), Occur.MUST);

        Query joinQuery = taxonBaseQueryFactory.newJoinQuery(fromField, toField, joinFromQuery, TaxonRelationship.class);

            finalQuery.add(taxonBaseQueryFactory.newEntityIdQuery("taxonNodes.classification.id", classification), Occur.MUST);

            luceneSearch.setHighlightFields(taxonBaseQueryFactory.getTextFieldNamesAsArray());

            Set<NamedArea> namedAreas, Set<PresenceAbsenceTermBase<?>> distributionStatus, List<Language> languages,

            boolean highlightFragments, Integer pageSize,

        if(highlightFragments){

            logger.warn("findTaxaAndNamesByFullText() : fragment highlighting is " +

                    "currently not fully supported by this method and thus " +

                    "may not work with common names and misapplied names.");

        }

        // convert sets to lists

        List<NamedArea> namedAreaList = null;

        List<PresenceAbsenceTermBase<?>>distributionStatusList = null;

        if(namedAreas != null){

            namedAreaList = new ArrayList<NamedArea>(namedAreas.size());

            namedAreaList.addAll(namedAreas);

        }

        if(distributionStatus != null){

            distributionStatusList = new ArrayList<PresenceAbsenceTermBase<?>>(distributionStatus.size());

            distributionStatusList.addAll(distributionStatus);

        }

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

        /*

          ======== filtering by distribution , HOWTO ========

           - http://www.javaranch.com/journal/2009/02/filtering-a-lucene-search.html

           - http://stackoverflow.com/questions/17709256/lucene-solr-using-complex-filters -> QueryWrapperFilter

          add Filter to search as http://lucene.apache.org/core/3_6_0/api/all/org/apache/lucene/search/Filter.html

          which will be put into a FilteredQuersy  in the end ?

          3. how does it work in spatial?

          see

           - http://www.nsshutdown.com/projects/lucene/whitepaper/locallucene_v2.html

           - http://www.infoq.com/articles/LuceneSpatialSupport

           - http://www.mhaller.de/archives/156-Spatial-search-with-Lucene.html

          ------------------------------------------------------------------------

          filter strategies:

          A) use a separate distribution filter per index sub-query/search:

           - byTaxonSyonym (query TaxaonBase):

               use a join area filter (Distribution -> TaxonBase)

           - byCommonName (query DescriptionElementBase): use an area filter on

               DescriptionElementBase !!! PROBLEM !!!

               This cannot work since the distributions are different entities than the

               common names and thus these are different lucene documents.

           - byMisaplliedNames (join query TaxonRelationship -> TaxaonBase):

               use a join area filter (Distribution -> TaxonBase)

          B) use a common distribution filter for all index sub-query/searches:

           - use a common join area filter (Distribution -> TaxonBase)

           - also implement the byCommonName as join query (CommonName -> TaxonBase)

           PROBLEM in this case: we are losing the fragment highlighting for the

           common names, since the returned documents are always TaxonBases

        */

        /* The QueryFactory for creating filter queries on Distributions should

         * The query factory used for the common names query cannot be reused

         * for this case, since we want to only record the text fields which are

         * actually used in the primary query

         */

        QueryFactory distributionFilterQueryFactory = luceneIndexToolProvider.newQueryFactoryFor(Distribution.class);

        BooleanFilter multiIndexByAreaFilter = new BooleanFilter();

        // search for taxa or synonyms

            /* A) does not work!!!!

            if(addDistributionFilter){

                // in this case we need a filter which uses a join query

                // to get the TaxonBase documents for the DescriptionElementBase documents

                // which are matching the areas in question

                Query taxonAreaJoinQuery = createByDistributionJoinQuery(

                        namedAreaList,

                        distributionStatusList,

                        distributionFilterQueryFactory

                        );

                multiIndexByAreaFilter.add(new QueryWrapperFilter(taxonAreaJoinQuery), Occur.SHOULD);

            }

            */

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

                // add additional area filter for synonyms

                String fromField = "inDescription.taxon.id"; // in DescriptionElementBase index

                String toField = "accTaxon.id"; // id in TaxonBase index

                BooleanQuery byDistributionQuery = createByDistributionQuery(namedAreaList, distributionStatusList, distributionFilterQueryFactory);

                Query taxonAreaJoinQuery = distributionFilterQueryFactory.newJoinQuery(fromField, toField, byDistributionQuery, Distribution.class);

                multiIndexByAreaFilter.add(new QueryWrapperFilter(taxonAreaJoinQuery), Occur.SHOULD);

            }

        // search by CommonTaxonName

            // B)

            QueryFactory descriptionElementQueryFactory = luceneIndexToolProvider.newQueryFactoryFor(DescriptionElementBase.class);

            Query byCommonNameJoinQuery = descriptionElementQueryFactory.newJoinQuery(

                    "inDescription.taxon.id",

                    "id",

                    createByDescriptionElementFullTextQuery(queryString, classification, null, languages, descriptionElementQueryFactory),

                    CommonTaxonName.class);

            logger.debug("byCommonNameJoinQuery: " + byCommonNameJoinQuery.toString());

            LuceneSearch byCommonNameSearch = new LuceneSearch(luceneIndexToolProvider, GroupByTaxonClassBridge.GROUPBY_TAXON_FIELD, Taxon.class);

            byCommonNameSearch.setCdmTypRestriction(Taxon.class);

            byCommonNameSearch.setQuery(byCommonNameJoinQuery);

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

            luceneSearches.add(byCommonNameSearch);

            /* A) does not work!!!!

            luceneSearches.add(

                    prepareByDescriptionElementFullTextSearch(CommonTaxonName.class,

                            queryString, classification, null, languages, highlightFragments)

                        );

            if(addDistributionFilter){

                // in this case we are able to use DescriptionElementBase documents

                // which are matching the areas in question directly

                BooleanQuery byDistributionQuery = createByDistributionQuery(

                        namedAreaList,

                        distributionStatusList,

                        distributionFilterQueryFactory

                        );

                multiIndexByAreaFilter.add(new QueryWrapperFilter(byDistributionQuery), Occur.SHOULD);

            } */

        }

        // search by misapplied names

            // finds the misapplied name (Taxon B) which is an misapplication for

            // a related Taxon A.

            //

            if(addDistributionFilter){

                String fromField = "inDescription.taxon.id"; // in DescriptionElementBase index

                /*

                 * Here i was facing wired and nasty bug which took me bugging be really for hours until I found this solution.

                 * Maybe this is a but in java itself java.

                 *

                 * When the string toField is constructed by using the expression TaxonRelationshipType.MISAPPLIED_NAME_FOR().getUuid().toString()

                 * directly:

                 *

                 *    String toField = "relation." + TaxonRelationshipType.MISAPPLIED_NAME_FOR().getUuid().toString() +".to.id";

                 *

                 * The byDistributionQuery fails, however when the uuid is first stored in another string variable the query

                 * will execute as expected:

                 *

                 *    String misappliedNameForUuid = TaxonRelationshipType.MISAPPLIED_NAME_FOR().getUuid().toString();

                 *    String toField = "relation." + misappliedNameForUuid +".to.id";

                 *

                 * Comparing both strings by the String.equals method returns true, so both String are identical.

                 *

                 * The bug occurs when running eu.etaxonomy.cdm.api.service.TaxonServiceSearchTest in eclipse and in maven and seems to to be

                 * dependent from a specific jvm (openjdk6  6b27-1.12.6-1ubuntu0.13.04.2, openjdk7 7u25-2.3.10-1ubuntu0.13.04.2,  oracle jdk1.7.0_25 tested)

                 * The bug is persistent after a reboot of the development computer.

                 */

//                String misappliedNameForUuid = TaxonRelationshipType.MISAPPLIED_NAME_FOR().getUuid().toString();

//                String toField = "relation." + misappliedNameForUuid +".to.id";

                String toField = "relation.1ed87175-59dd-437e-959e-0d71583d8417.to.id";

//                System.out.println("relation.1ed87175-59dd-437e-959e-0d71583d8417.to.id".equals("relation." + misappliedNameForUuid +".to.id") ? " > identical" : " > different");

//                System.out.println("relation.1ed87175-59dd-437e-959e-0d71583d8417.to.id".equals("relation." + TaxonRelationshipType.MISAPPLIED_NAME_FOR().getUuid().toString() +".to.id") ? " > identical" : " > different");

                BooleanQuery byDistributionQuery = createByDistributionQuery(namedAreaList, distributionStatusList, distributionFilterQueryFactory);

                Query taxonAreaJoinQuery = distributionFilterQueryFactory.newJoinQuery(fromField, toField, byDistributionQuery, Distribution.class);

                QueryWrapperFilter filter = new QueryWrapperFilter(taxonAreaJoinQuery);

//                debug code for bug described above

                DocIdSet filterMatchSet = filter.getDocIdSet(luceneIndexToolProvider.getIndexReaderFor(Taxon.class));

                System.err.println(DocIdBitSetPrinter.docsAsString(filterMatchSet, 100));

                multiIndexByAreaFilter.add(filter, Occur.SHOULD);

            }

        LuceneMultiSearch multiSearch = new LuceneMultiSearch(luceneIndexToolProvider,

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

        if(addDistributionFilter){

            // B)

            // in this case we need a filter which uses a join query

            // to get the TaxonBase documents for the DescriptionElementBase documents

            // which are matching the areas in question

            //

            // for toTaxa, doByCommonName

            Query taxonAreaJoinQuery = createByDistributionJoinQuery(

                    namedAreaList,

                    distributionStatusList,

                    distributionFilterQueryFactory

                    );

            multiIndexByAreaFilter.add(new QueryWrapperFilter(taxonAreaJoinQuery), Occur.SHOULD);

        }

        if (addDistributionFilter){

            multiSearch.setFilter(multiIndexByAreaFilter);

        }

    /**

     * @param namedAreaList at least one area must be in the list

     * @param distributionStatusList optional

     * @return

     * @throws IOException

     */

    protected Query createByDistributionJoinQuery(

            List<NamedArea> namedAreaList,

            List<PresenceAbsenceTermBase<?>> distributionStatusList,

            QueryFactory queryFactory

            ) throws IOException {

        String fromField = "inDescription.taxon.id"; // in DescriptionElementBase index

        String toField = "id"; // id in TaxonBase index

        BooleanQuery byDistributionQuery = createByDistributionQuery(namedAreaList, distributionStatusList, queryFactory);

        Query taxonAreaJoinQuery = queryFactory.newJoinQuery(fromField, toField, byDistributionQuery, Distribution.class);

        return taxonAreaJoinQuery;

    }

    /**

     * @param namedAreaList

     * @param distributionStatusList

     * @param queryFactory

     * @return

     */

    private BooleanQuery createByDistributionQuery(List<NamedArea> namedAreaList,

            List<PresenceAbsenceTermBase<?>> distributionStatusList, QueryFactory queryFactory) {

        BooleanQuery areaQuery = new BooleanQuery();

        // area field from Distribution

        areaQuery.add(queryFactory.newEntityIdsQuery("area.id", namedAreaList), Occur.MUST);

        // status field from Distribution

        if(distributionStatusList != null && distributionStatusList.size() > 0){

            areaQuery.add(queryFactory.newEntityIdsQuery("status.id", distributionStatusList), Occur.MUST);

        }

        logger.debug("createByDistributionQuery() query: " + areaQuery.toString());

        return areaQuery;

    }

    /**

     * This method has been primarily created for testing the area join query but might

     * also be useful in other situations

     *

     * @param namedAreaList

     * @param distributionStatusList

     * @param classification

     * @param highlightFragments

     * @return

     * @throws IOException

     */

    protected LuceneSearch prepareByDistributionSearch(

            List<NamedArea> namedAreaList, List<PresenceAbsenceTermBase<?>> distributionStatusList,

            Classification classification) throws IOException {

        BooleanQuery finalQuery = new BooleanQuery();

        LuceneSearch luceneSearch = new LuceneSearch(luceneIndexToolProvider, GroupByTaxonClassBridge.GROUPBY_TAXON_FIELD, Taxon.class);

        // FIXME is this query factory using the wrong type?

        QueryFactory taxonQueryFactory = luceneIndexToolProvider.newQueryFactoryFor(Taxon.class);

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

        luceneSearch.setSortFields(sortFields);

        Query byAreaQuery = createByDistributionJoinQuery(namedAreaList, distributionStatusList, taxonQueryFactory);

        finalQuery.add(byAreaQuery, Occur.MUST);

        if(classification != null){

            finalQuery.add(taxonQueryFactory.newEntityIdQuery("taxonNodes.classification.id", classification), Occur.MUST);

        }

        logger.info("prepareByAreaSearch() query: " + finalQuery.toString());

        luceneSearch.setQuery(finalQuery);

        return luceneSearch;

    }

        LuceneMultiSearch multiSearch = new LuceneMultiSearch(luceneIndexToolProvider, luceneSearchByDescriptionElement, luceneSearchByTaxonBase);

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

            String queryString, Classification classification, List<Feature> features,

        LuceneSearch luceneSearch = new LuceneSearch(luceneIndexToolProvider, GroupByTaxonClassBridge.GROUPBY_TAXON_FIELD, DescriptionElementBase.class);

        QueryFactory descriptionElementQueryFactory = luceneIndexToolProvider.newQueryFactoryFor(DescriptionElementBase.class);

        BooleanQuery finalQuery = createByDescriptionElementFullTextQuery(queryString, classification, features,

                languages, descriptionElementQueryFactory);

        luceneSearch.setCdmTypRestriction(clazz);

        luceneSearch.setQuery(finalQuery);

        if(highlightFragments){

            luceneSearch.setHighlightFields(descriptionElementQueryFactory.getTextFieldNamesAsArray());

        }

        return luceneSearch;

    }

    /**

     * @param queryString

     * @param classification

     * @param features

     * @param languages

     * @param descriptionElementQueryFactory

     * @return

     */

    private BooleanQuery createByDescriptionElementFullTextQuery(String queryString, Classification classification,

            List<Feature> features, List<Language> languages, QueryFactory descriptionElementQueryFactory) {

        BooleanQuery finalQuery = new BooleanQuery();

        BooleanQuery textQuery = new BooleanQuery();

        textQuery.add(descriptionElementQueryFactory.newTermQuery("titleCache", queryString), Occur.SHOULD);

            nameQuery = descriptionElementQueryFactory.newTermQuery("name", queryString);

                languageSubQuery.add(descriptionElementQueryFactory.newTermQuery("language.uuid",  lang.getUuid().toString(), false), Occur.SHOULD);

            ((BooleanQuery) nameQuery).add(descriptionElementQueryFactory.newTermQuery("name", queryString), Occur.MUST);

        textQuery.add(descriptionElementQueryFactory.newMultilanguageTextQuery("text", queryString, languages), Occur.SHOULD);

        textQuery.add(descriptionElementQueryFactory.newDefinedTermQuery("stateData.state", queryString, languages), Occur.SHOULD);

        textQuery.add(descriptionElementQueryFactory.newDefinedTermQuery("stateData.modifyingText", queryString, languages), Occur.SHOULD);

        textQuery.add(descriptionElementQueryFactory.newDefinedTermQuery("area", queryString, languages), Occur.SHOULD);

        textQuery.add(descriptionElementQueryFactory.newDefinedTermQuery("status", queryString, languages), Occur.SHOULD);

            finalQuery.add(descriptionElementQueryFactory.newEntityIdQuery("inDescription.taxon.taxonNodes.classification.id", classification), Occur.MUST);

            finalQuery.add(descriptionElementQueryFactory.newEntityUuidsQuery("feature.uuid", features), Occur.MUST);

        finalQuery.add(descriptionElementQueryFactory.newIsNotNullQuery("inDescription.taxon.id"), Occur.MUST);

        return finalQuery;

            logger.warn("The synonym has no sec reference because it is a misapplied name! Take the sec reference of taxon" + taxon.getSec());