package org.apache.maven.index.incremental;

 /*

  * 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 org.apache.lucene.document.Document;

 import org.apache.lucene.index.IndexReader;

 import org.apache.maven.index.ArtifactInfo;

 import org.apache.maven.index.context.IndexingContext;

 import org.apache.maven.index.packer.IndexPackingRequest;

 import org.apache.maven.index.updater.IndexUpdateRequest;

 import org.codehaus.plexus.component.annotations.Component;

 import org.codehaus.plexus.logging.AbstractLogEnabled;

 import org.codehaus.plexus.util.StringUtils;

 import java.io.File;

 import java.io.FilenameFilter;

 import java.io.IOException;

 import java.text.ParseException;

 import java.text.SimpleDateFormat;

 import java.util.ArrayList;

 import java.util.Date;

 import java.util.HashSet;

 import java.util.List;

 import java.util.Map;

 import java.util.Map.Entry;

 import java.util.Properties;

 import java.util.Set;

 import java.util.TimeZone;

 import java.util.TreeMap;

 @Component( role = IncrementalHandler.class )

 public class DefaultIncrementalHandler

     extends AbstractLogEnabled

     implements IncrementalHandler

 {

     public List<Integer> getIncrementalUpdates( IndexPackingRequest request, Properties properties )

         throws IOException

     {

         getLogger().debug( "Handling Incremental Updates" );

         if ( !validateProperties( properties ) )

         {

             getLogger().debug( "Invalid properties found, resetting them and doing no incremental packing." );

             return null;

         }

         // Get the list of document ids that have been added since the last time

         // the index ran

         List<Integer> chunk =

             getIndexChunk( request, parse( properties.getProperty( IndexingContext.INDEX_TIMESTAMP ) ) );

         getLogger().debug( "Found " + chunk.size() + " differences to put in incremental index." );

         // if no documents, then we don't need to do anything, no changes

         if ( chunk.size() > 0 )

         {

             updateProperties( properties, request );

         }

         cleanUpIncrementalChunks( request, properties );

         return chunk;

     }

     public List<String> loadRemoteIncrementalUpdates( IndexUpdateRequest request, Properties localProperties,

                                                       Properties remoteProperties )

         throws IOException

     {

         List<String> filenames = null;

         // If we have local properties, will parse and see what we need to download

         if ( canRetrieveAllChunks( localProperties, remoteProperties ) )

         {

             filenames = new ArrayList<String>();

             int maxCounter = Integer.parseInt( remoteProperties.getProperty( IndexingContext.INDEX_CHUNK_COUNTER ) );

             int currentCounter = Integer.parseInt( localProperties.getProperty( IndexingContext.INDEX_CHUNK_COUNTER ) );

             // Start with the next one

             currentCounter++;

             while ( currentCounter <= maxCounter )

             {

                 filenames.add( IndexingContext.INDEX_FILE_PREFIX + "." + currentCounter++ + ".gz" );

             }

         }

         return filenames;

     }

     private boolean validateProperties( Properties properties )

     {

         if ( properties == null || properties.isEmpty() )

         {

             return false;

         }

         if ( properties.getProperty( IndexingContext.INDEX_TIMESTAMP ) == null )

         {

             return false;

         }

         if ( parse( properties.getProperty( IndexingContext.INDEX_TIMESTAMP ) ) == null )

         {

             return false;

         }

         initializeProperties( properties );

         return true;

     }

     public void initializeProperties( Properties properties )

     {

         if ( properties.getProperty( IndexingContext.INDEX_CHAIN_ID ) == null )

         {

             properties.setProperty( IndexingContext.INDEX_CHAIN_ID, Long.toString( new Date().getTime() ) );

             properties.remove( IndexingContext.INDEX_CHUNK_COUNTER );

         }

         if ( properties.getProperty( IndexingContext.INDEX_CHUNK_COUNTER ) == null )

         {

             properties.setProperty( IndexingContext.INDEX_CHUNK_COUNTER, "0" );

         }

     }

     // Note Toni:

     private List<Integer> getIndexChunk( IndexPackingRequest request, Date timestamp )

         throws IOException

     {

         List<Integer> chunk = new ArrayList<Integer>();

         IndexReader r = request.getContext().getIndexReader();

         for ( int i = 0; i < r.maxDoc(); i++ )

         {

             if ( !r.isDeleted( i ) )

             {

                 Document d = r.document( i );

                 String lastModified = d.get( ArtifactInfo.LAST_MODIFIED );

                 if ( lastModified != null )

                 {

                     Date t = new Date( Long.parseLong( lastModified ) );

                     // Only add documents that were added after the last time we indexed

                     if ( t.after( timestamp ) )

                     {

                         chunk.add( i );

                     }

                 }

             }

         }

         return chunk;

     }

     private void updateProperties( Properties properties, IndexPackingRequest request )

         throws IOException

     {

         Set<Object> keys = new HashSet<Object>( properties.keySet() );

         Map<Integer, String> dataMap = new TreeMap<Integer, String>();

         // First go through and retrieve all keys and their values

         for ( Object key : keys )

         {

             String sKey = (String) key;

             if ( sKey.startsWith( IndexingContext.INDEX_CHUNK_PREFIX ) )

             {

                 Integer count = Integer.valueOf( sKey.substring( IndexingContext.INDEX_CHUNK_PREFIX.length() ) );

                 String value = properties.getProperty( sKey );

                 dataMap.put( count, value );

                 properties.remove( key );

             }

         }

         String val = (String) properties.getProperty( IndexingContext.INDEX_CHUNK_COUNTER );

         int i = 0;

         // Next put the items back in w/ proper keys

         for ( Entry<Integer, String> entry : dataMap.entrySet() )

         {

             // make sure to end if we reach limit, 0 based

             if ( i >= ( request.getMaxIndexChunks() - 1 ) )

             {

                 break;

             }

             properties.put( IndexingContext.INDEX_CHUNK_PREFIX + ( entry.getKey() + 1 ), entry.getValue() );

             i++;

         }

         int nextValue = Integer.parseInt( val ) + 1;

         // Now put the new one in, and update the counter

         properties.put( IndexingContext.INDEX_CHUNK_PREFIX + "0", Integer.toString( nextValue ) );

         properties.put( IndexingContext.INDEX_CHUNK_COUNTER, Integer.toString( nextValue ) );

     }

     private void cleanUpIncrementalChunks( IndexPackingRequest request, Properties properties )

         throws IOException

     {

         File[] files = request.getTargetDir().listFiles( new FilenameFilter()

         {

             public boolean accept( File dir, String name )

             {

                 String[] parts = name.split( "\\." );

                 if ( parts.length == 3 && parts[0].equals( IndexingContext.INDEX_FILE_PREFIX ) && parts[2].equals(

                     "gz" ) )

                 {

                     return true;

                 }

                 return false;

             }

         } );

         for ( int i = 0; i < files.length; i++ )

         {

             String[] parts = files[i].getName().split( "\\." );

             boolean found = false;

             for ( Entry<Object, Object> entry : properties.entrySet() )

             {

                 if ( entry.getKey().toString().startsWith( IndexingContext.INDEX_CHUNK_PREFIX )

                     && entry.getValue().equals( parts[1] ) )

                 {

                     found = true;

                     break;

                 }

             }

             if ( !found )

             {

                 files[i].delete();

             }

         }

     }

     private Date parse( String s )

     {

         try

         {

             SimpleDateFormat df = new SimpleDateFormat( IndexingContext.INDEX_TIME_FORMAT );

             df.setTimeZone( TimeZone.getTimeZone( "GMT" ) );

             return df.parse( s );

         }

         catch ( ParseException e )

         {

             return null;

         }

     }

     private boolean canRetrieveAllChunks( Properties localProps, Properties remoteProps )

     {

         // no localprops, can't retrieve chunks

         if ( localProps == null )

         {

             return false;

         }

         String localChainId = localProps.getProperty( IndexingContext.INDEX_CHAIN_ID );

         String remoteChainId = remoteProps.getProperty( IndexingContext.INDEX_CHAIN_ID );

         // If no chain id, or not the same, do whole download

         if ( StringUtils.isEmpty( localChainId ) || !localChainId.equals( remoteChainId ) )

         {

             return false;

         }

         String counterProp = localProps.getProperty( IndexingContext.INDEX_CHUNK_COUNTER );

         // no counter, cant retrieve chunks

         // not a number, cant retrieve chunks

         if ( StringUtils.isEmpty( counterProp ) || !StringUtils.isNumeric( counterProp ) )

         {

             return false;

         }

         int currentLocalCounter = Integer.parseInt( counterProp );

         // check remote props for existence of next chunk after local

         // if we find it, then we are ok to retrieve the rest of the chunks

         for ( Object key : remoteProps.keySet() )

         {

             String sKey = (String) key;

             if ( sKey.startsWith( IndexingContext.INDEX_CHUNK_PREFIX ) )

             {

                 String value = remoteProps.getProperty( sKey );

                 // If we have the current counter, or the next counter, we are good to go

                 if ( Integer.toString( currentLocalCounter ).equals( value ) || Integer.toString(

                     currentLocalCounter + 1 ).equals( value ) )

                 {

                     return true;

                 }

             }

         }

         return false;

     }

 }