package org.apache.maven.index;
   
   /*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you under the Apache License, Version 2.0 (the
    * "License"); you may not use this file except in compliance
   * with the License.  You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0    
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied.  See the License for the
   * specific language governing permissions and limitations
   * under the License.
   */
  
  import javax.inject.Named;
  import javax.inject.Singleton;
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.Comparator;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.TreeMap;
  import java.util.TreeSet;
  
  import org.apache.lucene.document.Document;
  import org.apache.lucene.search.IndexSearcher;
  import org.apache.lucene.search.Query;
  import org.apache.lucene.search.ScoreDoc;
  import org.apache.lucene.search.TopScoreDocCollector;
  import org.apache.maven.index.context.IndexUtils;
  import org.apache.maven.index.context.IndexingContext;
  import org.apache.maven.index.context.NexusIndexMultiReader;
  import org.apache.maven.index.context.NexusIndexMultiSearcher;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * A default search engine implementation
   * 
   * @author Eugene Kuleshov
   * @author Tamas Cservenak
   */
  @Singleton
  @Named
  public class DefaultSearchEngine
      implements SearchEngine
  {
  
      private final Logger logger = LoggerFactory.getLogger( getClass() );
  
      protected Logger getLogger()
      {
          return logger;
      }
  
      @Deprecated
      public Set<ArtifactInfo> searchFlat( Comparator<ArtifactInfo> artifactInfoComparator,
                                           IndexingContext indexingContext, Query query )
          throws IOException
      {
          return searchFlatPaged( new FlatSearchRequest( query, artifactInfoComparator, indexingContext ),
              Arrays.asList( indexingContext ), true ).getResults();
      }
  
      @Deprecated
      public Set<ArtifactInfo> searchFlat( Comparator<ArtifactInfo> artifactInfoComparator,
                                           Collection<IndexingContext> indexingContexts, Query query )
          throws IOException
      {
          return searchFlatPaged( new FlatSearchRequest( query, artifactInfoComparator ), indexingContexts ).getResults();
      }
  
      public FlatSearchResponse searchFlatPaged( FlatSearchRequest request, Collection<IndexingContext> indexingContexts )
          throws IOException
      {
          return searchFlatPaged( request, indexingContexts, false );
      }
  
      public FlatSearchResponse forceSearchFlatPaged( FlatSearchRequest request,
                                                      Collection<IndexingContext> indexingContexts )
          throws IOException
      {
          return searchFlatPaged( request, indexingContexts, true );
      }
  
      protected FlatSearchResponse searchFlatPaged( FlatSearchRequest request,
                                                    Collection<IndexingContext> indexingContexts, boolean ignoreContext )
          throws IOException
      {
         List<IndexingContext> contexts = getParticipatingContexts( indexingContexts, ignoreContext );
 
         final TreeSet<ArtifactInfo> result = new TreeSet<ArtifactInfo>( request.getArtifactInfoComparator() );
         return new FlatSearchResponse( request.getQuery(), searchFlat( request, result, contexts, request.getQuery() ),
             result );
     }
 
     // ==
 
     public GroupedSearchResponse searchGrouped( GroupedSearchRequest request,
                                                 Collection<IndexingContext> indexingContexts )
         throws IOException
     {
         return searchGrouped( request, indexingContexts, false );
     }
 
     public GroupedSearchResponse forceSearchGrouped( GroupedSearchRequest request,
                                                      Collection<IndexingContext> indexingContexts )
         throws IOException
     {
         return searchGrouped( request, indexingContexts, true );
     }
 
     protected GroupedSearchResponse searchGrouped( GroupedSearchRequest request,
                                                    Collection<IndexingContext> indexingContexts, boolean ignoreContext )
         throws IOException
     {
         List<IndexingContext> contexts = getParticipatingContexts( indexingContexts, ignoreContext );
 
         final TreeMap<String, ArtifactInfoGroup> result =
             new TreeMap<String, ArtifactInfoGroup>( request.getGroupKeyComparator() );
 
         return new GroupedSearchResponse( request.getQuery(), searchGrouped( request, result, request.getGrouping(),
             contexts, request.getQuery() ), result );
     }
 
     // ===
 
     protected int searchFlat( FlatSearchRequest req, Collection<ArtifactInfo> result,
                               List<IndexingContext> participatingContexts, Query query )
         throws IOException
     {
         int hitCount = 0;
         for ( IndexingContext context : participatingContexts )
         {
             final IndexSearcher indexSearcher = context.acquireIndexSearcher();
             try
             {
                 final TopScoreDocCollector collector = doSearchWithCeiling( req, indexSearcher, query );
 
                 if ( collector.getTotalHits() == 0 )
                 {
                     // context has no hits, just continue to next one
                     continue;
                 }
 
                 ScoreDoc[] scoreDocs = collector.topDocs().scoreDocs;
 
                 // uhm btw hitCount contains dups
 
                 hitCount += collector.getTotalHits();
 
                 int start = 0; // from == FlatSearchRequest.UNDEFINED ? 0 : from;
 
                 // we have to pack the results as long: a) we have found aiCount ones b) we depleted hits
                 for ( int i = start; i < scoreDocs.length; i++ )
                 {
                     Document doc = indexSearcher.doc( scoreDocs[i].doc );
 
                     ArtifactInfo artifactInfo = IndexUtils.constructArtifactInfo( doc, context );
 
                     if ( artifactInfo != null )
                     {
                         artifactInfo.setRepository( context.getRepositoryId() );
                         artifactInfo.setContext( context.getId() );
 
                         if ( req.getArtifactInfoFilter() != null )
                         {
                             if ( !req.getArtifactInfoFilter().accepts( context, artifactInfo ) )
                             {
                                 continue;
                             }
                         }
                         if ( req.getArtifactInfoPostprocessor() != null )
                         {
                             req.getArtifactInfoPostprocessor().postprocess( context, artifactInfo );
                         }
 
                         result.add( artifactInfo );
                     }
                 }
             }
             finally
             {
                 context.releaseIndexSearcher( indexSearcher );
             }
         }
 
         return hitCount;
     }
 
     protected int searchGrouped( GroupedSearchRequest req, Map<String, ArtifactInfoGroup> result, Grouping grouping,
                                  List<IndexingContext> participatingContexts, Query query )
         throws IOException
     {
         int hitCount = 0;
 
         for ( IndexingContext context : participatingContexts )
         {
             final IndexSearcher indexSearcher = context.acquireIndexSearcher();
             try
             {
                 final TopScoreDocCollector collector = doSearchWithCeiling( req, indexSearcher, query );
 
                 if ( collector.getTotalHits() > 0 )
                 {
                     ScoreDoc[] scoreDocs = collector.topDocs().scoreDocs;
 
                     hitCount += collector.getTotalHits();
 
                     for ( int i = 0; i < scoreDocs.length; i++ )
                     {
                         Document doc = indexSearcher.doc( scoreDocs[i].doc );
 
                         ArtifactInfo artifactInfo = IndexUtils.constructArtifactInfo( doc, context );
 
                         if ( artifactInfo != null )
                         {
                             artifactInfo.setRepository( context.getRepositoryId() );
                             artifactInfo.setContext( context.getId() );
 
                             if ( req.getArtifactInfoFilter() != null )
                             {
                                 if ( !req.getArtifactInfoFilter().accepts( context, artifactInfo ) )
                                 {
                                     continue;
                                 }
                             }
                             if ( req.getArtifactInfoPostprocessor() != null )
                             {
                                 req.getArtifactInfoPostprocessor().postprocess( context, artifactInfo );
                             }
 
                             if ( !grouping.addArtifactInfo( result, artifactInfo ) )
                             {
                                 // fix the hitCount accordingly
                                 hitCount--;
                             }
                         }
                     }
                 }
             }
             finally
             {
                 context.releaseIndexSearcher( indexSearcher );
             }
         }
 
         return hitCount;
     }
 
     // == NG Search
 
     public IteratorSearchResponse searchIteratorPaged( IteratorSearchRequest request,
                                                        Collection<IndexingContext> indexingContexts )
         throws IOException
     {
         return searchIteratorPaged( request, indexingContexts, false );
     }
 
     public IteratorSearchResponse forceSearchIteratorPaged( IteratorSearchRequest request,
                                                             Collection<IndexingContext> indexingContexts )
         throws IOException
     {
         return searchIteratorPaged( request, indexingContexts, true );
     }
 
     private IteratorSearchResponse searchIteratorPaged( IteratorSearchRequest request,
                                                         Collection<IndexingContext> indexingContexts,
                                                         boolean ignoreContext )
         throws IOException
     {
         List<IndexingContext> contexts = getParticipatingContexts( indexingContexts, ignoreContext );
 
         NexusIndexMultiReader multiReader = getMergedIndexReader( indexingContexts, ignoreContext );
 
         NexusIndexMultiSearcher indexSearcher = new NexusIndexMultiSearcher( multiReader );
 
         try
         {
             TopScoreDocCollector hits = doSearchWithCeiling( request, indexSearcher, request.getQuery() );
 
             return new IteratorSearchResponse( request.getQuery(), hits.getTotalHits(),
                                                new DefaultIteratorResultSet( request, indexSearcher, contexts,
                                                                              hits.topDocs() ) );
         }
         catch ( IOException e )
         {
             try
             {
                 indexSearcher.release();
             }
             catch ( Exception secondary )
             {
                 // do not mask original exception
             }
             throw e;
         }
         catch ( RuntimeException e )
         {
             try
             {
                 indexSearcher.release();
             }
             catch ( Exception secondary )
             {
                 // do not mask original exception
             }
             throw e;
         }
     }
 
     // ==
 
     protected TopScoreDocCollector doSearchWithCeiling( final AbstractSearchRequest request,
                                                         final IndexSearcher indexSearcher, final Query query )
         throws IOException
     {
         int topHitCount = getTopDocsCollectorHitNum( request, AbstractSearchRequest.UNDEFINED );
 
         if ( AbstractSearchRequest.UNDEFINED != topHitCount )
         {
             // count is set, simply just execute it as-is
             final TopScoreDocCollector hits = TopScoreDocCollector.create( topHitCount );
 
             indexSearcher.search( query, hits );
 
             return hits;
         }
         else
         {
             // set something reasonable as 1k
             topHitCount = 1000;
 
             // perform search
             TopScoreDocCollector hits = TopScoreDocCollector.create( topHitCount );
             indexSearcher.search( query, hits );
 
             // check total hits against, does it fit?
             if ( topHitCount < hits.getTotalHits() )
             {
                 topHitCount = hits.getTotalHits();
 
                 if ( getLogger().isDebugEnabled() )
                 {
                     // warn the user and leave trace just before OOM might happen
                     // the hits.getTotalHits() might be HUUGE
                     getLogger().debug(
                         "Executing unbounded search, and fitting topHitCounts to " + topHitCount
                         + ", an OOMEx might follow. To avoid OOM use narrower queries or limit your expectancy with "
                         + "request.setCount() method where appropriate. See MINDEXER-14 for details." );
                 }
 
                 // redo all, but this time with correct numbers
                 hits = TopScoreDocCollector.create( topHitCount );
                 indexSearcher.search( query, hits );
             }
 
             return hits;
         }
     }
 
     /**
      * Returns the list of participating contexts. Does not locks them, just builds a list of them.
      */
     protected List<IndexingContext> getParticipatingContexts( final Collection<IndexingContext> indexingContexts,
                                                               final boolean ignoreContext )
     {
         // to not change the API all away, but we need stable ordering here
         // filter for those 1st, that take part in here
         final ArrayList<IndexingContext> contexts = new ArrayList<IndexingContext>( indexingContexts.size() );
 
         for ( IndexingContext ctx : indexingContexts )
         {
             if ( ignoreContext || ctx.isSearchable() )
             {
                 contexts.add( ctx );
             }
         }
 
         return contexts;
     }
 
     /**
      * Locks down participating contexts, and returns a "merged" reader of them. In case of error, unlocks as part of
      * cleanup and re-throws exception. Without error, it is the duty of caller to unlock contexts!
      * 
      * @param indexingContexts
      * @param ignoreContext
      * @return
      * @throws IOException
      */
     protected NexusIndexMultiReader getMergedIndexReader( final Collection<IndexingContext> indexingContexts,
                                                           final boolean ignoreContext )
         throws IOException
     {
         final List<IndexingContext> contexts = getParticipatingContexts( indexingContexts, ignoreContext );
         return new NexusIndexMultiReader( contexts );
     }
 
     protected int getTopDocsCollectorHitNum( final AbstractSearchRequest request, final int ceiling )
     {
         if ( request instanceof AbstractSearchPageableRequest )
         {
             final AbstractSearchPageableRequest prequest = (AbstractSearchPageableRequest) request;
 
             if ( AbstractSearchRequest.UNDEFINED != prequest.getCount() )
             {
                 // easy, user knows and tells us how many results he want
                 return prequest.getCount() + prequest.getStart();
             }
         }
         else
         {
             if ( AbstractSearchRequest.UNDEFINED != request.getCount() )
             {
                 // easy, user knows and tells us how many results he want
                 return request.getCount();
             }
         }
 
         return ceiling;
     }
 }