package org.apache.maven.index.reader;
   
   /*
    * 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.maven.index.reader.ResourceHandler.Resource;
  
  import java.io.Closeable;
  import java.io.IOException;
  import java.text.ParseException;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.Date;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Objects;
  import java.util.Properties;
  
  import static org.apache.maven.index.reader.Utils.loadProperties;
  import static org.apache.maven.index.reader.Utils.storeProperties;
  
  /**
   * Maven 2 Index reader that handles incremental updates if possible and provides one or more {@link ChunkReader}s, to
   * read all the required records.
   *
   * @since 5.1.2
   */
  public class IndexReader
      implements Iterable<ChunkReader>, Closeable
  {
      private final WritableResourceHandler local;
  
      private final ResourceHandler remote;
  
      private final Properties localIndexProperties;
  
      private final Properties remoteIndexProperties;
  
      private final String indexId;
  
      private final Date publishedTimestamp;
  
      private final boolean incremental;
  
      private final List<String> chunkNames;
  
      public IndexReader( final WritableResourceHandler local, final ResourceHandler remote )
          throws IOException
      {
          Objects.requireNonNull( remote, "remote resource handler null" );
          this.local = local;
          this.remote = remote;
          remoteIndexProperties = loadProperties( remote.locate( Utils.INDEX_FILE_PREFIX + ".properties" ) );
          if ( remoteIndexProperties == null )
          {
              throw new IllegalArgumentException( "Non-existent remote index" );
          }
          try
          {
              if ( local != null )
              {
                  Properties localProperties =
                          loadProperties( local.locate( Utils.INDEX_FILE_PREFIX + ".properties" ) );
                  if ( localProperties != null )
                  {
                      this.localIndexProperties = localProperties;
                      String remoteIndexId = remoteIndexProperties.getProperty( "nexus.index.id" );
                      String localIndexId = localIndexProperties.getProperty( "nexus.index.id" );
                      if ( remoteIndexId == null || !remoteIndexId.equals( localIndexId ) )
                      {
                          throw new IllegalArgumentException(
                              "local and remote index IDs does not match or is null: " + localIndexId + ", "
                                  + remoteIndexId );
                      }
                      this.indexId = localIndexId;
                      this.incremental = canRetrieveAllChunks();
                  }
                  else
                  {
                      localIndexProperties = null;
                      this.indexId = remoteIndexProperties.getProperty( "nexus.index.id" );
                      this.incremental = false;
                  }
             }
             else
             {
                 localIndexProperties = null;
                 this.indexId = remoteIndexProperties.getProperty( "nexus.index.id" );
                 this.incremental = false;
             }
             this.publishedTimestamp =
                 Utils.INDEX_DATE_FORMAT.parse( remoteIndexProperties.getProperty( "nexus.index.timestamp" ) );
             this.chunkNames = calculateChunkNames();
         }
         catch ( ParseException e )
         {
             throw new IOException( "Index properties corrupted", e );
         }
     }
 
     /**
      * Returns the index context ID that published index has set. Usually it is equal to "repository ID" used in {@link
      * Record.Type#DESCRIPTOR} but does not have to be.
      */
     public String getIndexId()
     {
         return indexId;
     }
 
     /**
      * Returns the {@link Date} when remote index was last published.
      */
     public Date getPublishedTimestamp()
     {
         return publishedTimestamp;
     }
 
     /**
      * Returns {@code true} if incremental update is about to happen. If incremental update, the {@link #iterator()}
      * will return only the diff from the last update.
      */
     public boolean isIncremental()
     {
         return incremental;
     }
 
     /**
      * Returns unmodifiable list of actual chunks that needs to be pulled from remote {@link ResourceHandler}. Those are
      * incremental chunks or the big main file, depending on result of {@link #isIncremental()}. Empty list means local
      * index is up to date, and {@link #iterator()} will return empty iterator.
      */
     public List<String> getChunkNames()
     {
         return chunkNames;
     }
 
     /**
      * Closes the underlying {@link ResourceHandler}s. In case of incremental update use, it also assumes that user
      * consumed all the iterator and integrated it, hence, it will update the {@link WritableResourceHandler} contents
      * to prepare it for future incremental update. If this is not desired (ie. due to aborted update), then this
      * method should NOT be invoked, but rather the {@link ResourceHandler}s that caller provided in constructor of
      * this class should be closed manually.
      */
     public void close()
         throws IOException
     {
         remote.close();
         if ( local != null )
         {
             try
             {
                 syncLocalWithRemote();
             }
             finally
             {
                 local.close();
             }
         }
     }
 
     /**
      * Returns an {@link Iterator} of {@link ChunkReader}s, that if read in sequence, provide all the (incremental)
      * updates from the index. It is caller responsibility to either consume fully this iterator, or to close current
      * {@link ChunkReader} if aborting.
      */
     public Iterator<ChunkReader> iterator()
     {
         return new ChunkReaderIterator( remote, chunkNames.iterator() );
     }
 
     /**
      * Stores the remote index properties into local index properties, preparing local {@link WritableResourceHandler}
      * for future incremental updates.
      */
     private void syncLocalWithRemote()
         throws IOException
     {
         storeProperties( local.locate( Utils.INDEX_FILE_PREFIX + ".properties" ), remoteIndexProperties );
     }
 
     /**
      * Calculates the chunk names that needs to be fetched.
      */
     private List<String> calculateChunkNames()
     {
         if ( incremental )
         {
             ArrayList<String> chunkNames = new ArrayList<>();
             int maxCounter = Integer.parseInt( remoteIndexProperties.getProperty( "nexus.index.last-incremental" ) );
             int currentCounter = Integer.parseInt( localIndexProperties.getProperty( "nexus.index.last-incremental" ) );
             currentCounter++;
             while ( currentCounter <= maxCounter )
             {
                 chunkNames.add( Utils.INDEX_FILE_PREFIX + "." + currentCounter++ + ".gz" );
             }
             return Collections.unmodifiableList( chunkNames );
         }
         else
         {
             return Collections.singletonList( Utils.INDEX_FILE_PREFIX + ".gz" );
         }
     }
 
     /**
      * Verifies incremental update is possible, as all the diff chunks we need are still enlisted in remote properties.
      */
     private boolean canRetrieveAllChunks()
     {
         String localChainId = localIndexProperties.getProperty( "nexus.index.chain-id" );
         String remoteChainId = remoteIndexProperties.getProperty( "nexus.index.chain-id" );
 
         // If no chain id, or not the same, do full update
         if ( localChainId == null || !localChainId.equals( remoteChainId ) )
         {
             return false;
         }
 
         try
         {
             int localLastIncremental =
                 Integer.parseInt( localIndexProperties.getProperty( "nexus.index.last-incremental" ) );
             String currentLocalCounter = String.valueOf( localLastIncremental );
             String nextLocalCounter = String.valueOf( localLastIncremental + 1 );
             // check remote props for existence of current or next chunk after local
             for ( Object key : remoteIndexProperties.keySet() )
             {
                 String sKey = (String) key;
                 if ( sKey.startsWith( "nexus.index.incremental-" ) )
                 {
                     String value = remoteIndexProperties.getProperty( sKey );
                     if ( currentLocalCounter.equals( value ) || nextLocalCounter.equals( value ) )
                     {
                         return true;
                     }
                 }
             }
         }
         catch ( NumberFormatException e )
         {
             // fall through
         }
         return false;
     }
 
     /**
      * Internal iterator implementation that lazily opens and closes the returned {@link ChunkReader}s as this iterator
      * is being consumed.
      */
     private static class ChunkReaderIterator
         implements Iterator<ChunkReader>
     {
         private final ResourceHandler resourceHandler;
 
         private final Iterator<String> chunkNamesIterator;
 
         private Resource currentResource;
 
         private ChunkReader currentChunkReader;
 
         private ChunkReaderIterator( final ResourceHandler resourceHandler, final Iterator<String> chunkNamesIterator )
         {
             this.resourceHandler = resourceHandler;
             this.chunkNamesIterator = chunkNamesIterator;
         }
 
         public boolean hasNext()
         {
             return chunkNamesIterator.hasNext();
         }
 
         public ChunkReader next()
         {
             String chunkName = chunkNamesIterator.next();
             try
             {
                 if ( currentChunkReader != null )
                 {
                     currentChunkReader.close();
                 }
                 currentResource = resourceHandler.locate( chunkName );
                 currentChunkReader = new ChunkReader( chunkName, currentResource.read() );
                 return currentChunkReader;
             }
             catch ( IOException e )
             {
                 throw new RuntimeException( "IO problem while switching chunk readers", e );
             }
         }
 
         public void remove()
         {
             throw new UnsupportedOperationException( "remove" );
         }
     }
 }