package org.apache.maven.index.context;
   
   /*
    * 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 java.io.File;
  import java.io.FileNotFoundException;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.nio.file.NoSuchFileException;
  import java.util.Date;
  
  import org.apache.lucene.document.Document;
  import org.apache.lucene.document.Field;
  import org.apache.lucene.index.IndexReader;
  import org.apache.lucene.index.IndexWriter;
  import org.apache.lucene.store.Directory;
  import org.apache.lucene.store.IOContext;
  import org.apache.lucene.store.IndexInput;
  import org.apache.lucene.store.IndexOutput;
  import org.apache.maven.index.ArtifactInfo;
  import org.codehaus.plexus.util.FileUtils;
  
  public class IndexUtils
  {
      public static final String TIMESTAMP_FILE = "timestamp";
  
      private static final int BUFFER_SIZE = 16384;
  
      // Directory
  
      public static void copyDirectory( Directory source, Directory target )
          throws IOException
      {
          //FIXME: check if this copies too much, Lucene 4 has no filter for lucene files
          //Directory.copy( source, target, false );
          
          for ( String file : source.listAll() )
          {
              target.copyFrom( source, file, file, IOContext.DEFAULT );
          }
  
          copyFile( source, target, IndexingContext.INDEX_UPDATER_PROPERTIES_FILE );
          copyFile( source, target, IndexingContext.INDEX_PACKER_PROPERTIES_FILE );
  
          Date ts = getTimestamp( source );
          updateTimestamp( target, ts );
      }
  
      public static boolean copyFile( Directory source, Directory target, String name )
          throws IOException
      {
          return copyFile( source, target, name, name );
      }
  
      public static boolean copyFile( Directory source, Directory target, String srcName, String targetName )
          throws IOException
      {
          try
          {
              source.fileLength( srcName ); // instead of fileExists
          }
          catch ( FileNotFoundException | NoSuchFileException e )
          {
              return false;
          }
          target.copyFrom( source, srcName, targetName, IOContext.DEFAULT );
          return true;
      }
  
      // timestamp
  
      public static ArtifactInfo constructArtifactInfo( Document doc, IndexingContext context )
      {
          // if no UINFO can't create, must be a different type of record
          if ( doc.get( ArtifactInfo.UINFO ) == null )
          {
              return null;
          }
  
          boolean res = false;
  
         ArtifactInfo artifactInfo = new ArtifactInfo();
 
         // Add minimal information to the artifact info linking it to the context it belongs to.
         try
         {
             artifactInfo.setRepository( context.getRepositoryId() );
         }
         catch ( UnsupportedOperationException e )
         {
             // we ignore that as PartialImplementation can generate this UnsupportedOperationException
         }
         try
         {
             artifactInfo.setContext( context.getId() );
         }
         catch ( Exception e )
         {
             // we ignore that as PartialImplementation can generate this UnsupportedOperationException
         }
 
         for ( IndexCreator ic : context.getIndexCreators() )
         {
             res |= ic.updateArtifactInfo( doc, artifactInfo );
         }
 
         return res ? artifactInfo : null;
     }
 
     public static Document updateDocument( Document doc, IndexingContext context )
     {
         return updateDocument( doc, context, true );
     }
 
     public static Document updateDocument( Document doc, IndexingContext context, boolean updateLastModified )
     {
         return updateDocument( doc, context, updateLastModified, null );
     }
 
     public static Document updateDocument( Document doc, IndexingContext context, boolean updateLastModified,
                                            ArtifactInfo ai )
     {
         if ( ai == null )
         {
             ai = constructArtifactInfo( doc, context );
             if ( ai == null )
             {
                 return doc;
             }
         }
         Document document = new Document();
 
         // unique key
         document.add( new Field( ArtifactInfo.UINFO, ai.getUinfo(), Field.Store.YES, Field.Index.NOT_ANALYZED ) );
 
         if ( updateLastModified || doc.getField( ArtifactInfo.LAST_MODIFIED ) == null )
         {
             document.add( new Field( ArtifactInfo.LAST_MODIFIED, //
                 Long.toString( System.currentTimeMillis() ), Field.Store.YES, Field.Index.NO ) );
         }
         else
         {
             document.add( doc.getField( ArtifactInfo.LAST_MODIFIED ) );
         }
 
         for ( IndexCreator ic : context.getIndexCreators() )
         {
             ic.updateDocument( ai, document );
         }
 
         return document;
     }
 
     public static void deleteTimestamp( Directory directory )
         throws IOException
     {
         try
         {
             directory.deleteFile( TIMESTAMP_FILE );
         }
         catch ( FileNotFoundException | NoSuchFileException e )
         {
             //Does not exist
         }
     }
 
     public static void updateTimestamp( Directory directory, Date timestamp )
         throws IOException
     {
         synchronized ( directory )
         {
             Date currentTimestamp = getTimestamp( directory );
 
             if ( timestamp != null && ( currentTimestamp == null || !currentTimestamp.equals( timestamp ) ) )
             {
                 deleteTimestamp( directory );
 
                 IndexOutput io = directory.createOutput( TIMESTAMP_FILE, IOContext.DEFAULT );
 
                 try
                 {
                     io.writeLong( timestamp.getTime() );
                 }
                 finally
                 {
                     close( io );
                 }
             }
         }
     }
 
     public static Date getTimestamp( Directory directory )
     {
         synchronized ( directory )
         {
             Date result = null;
             try ( IndexInput ii = directory.openInput( TIMESTAMP_FILE, IOContext.DEFAULT ) )
             {
                 result = new Date( ii.readLong() );
             }
             catch ( FileNotFoundException | NoSuchFileException e )
             {
                 // Does not exist
             }
             catch ( IOException ex )
             {
                 // IO failure
             }
 
             return result;
         }
     }
 
     // close helpers
 
     public static void close( OutputStream os )
     {
         if ( os != null )
         {
             try
             {
                 os.close();
             }
             catch ( IOException e )
             {
                 // ignore
             }
         }
     }
 
     public static void close( InputStream is )
     {
         if ( is != null )
         {
             try
             {
                 is.close();
             }
             catch ( IOException e )
             {
                 // ignore
             }
         }
     }
 
     public static void close( IndexOutput io )
     {
         if ( io != null )
         {
             try
             {
                 io.close();
             }
             catch ( IOException e )
             {
                 // ignore
             }
         }
     }
 
     public static void close( IndexInput in )
     {
         if ( in != null )
         {
             try
             {
                 in.close();
             }
             catch ( IOException e )
             {
                 // ignore
             }
         }
     }
 
     public static void close( IndexReader r )
     {
         if ( r != null )
         {
             try
             {
                 r.close();
             }
             catch ( IOException e )
             {
                 // ignore
             }
         }
     }
 
     public static void close( IndexWriter w )
     {
         if ( w != null )
         {
             try
             {
                 w.close();
             }
             catch ( IOException e )
             {
                 // ignore
             }
         }
     }
 
     public static void close( Directory d )
     {
         if ( d != null )
         {
             try
             {
                 d.close();
             }
             catch ( IOException e )
             {
                 // ignore
             }
         }
     }
 
     public static void delete( File indexDir )
     {
         try
         {
             FileUtils.deleteDirectory( indexDir );
         }
         catch ( IOException ex )
         {
             // ignore
         }
     }
 
 }