package com.atlassian.bonnie;
   
   import java.io.File;
   import java.io.IOException;
   import java.util.concurrent.atomic.AtomicBoolean;
   import java.util.concurrent.atomic.AtomicReference;
   import java.util.concurrent.locks.Lock;
   
   import org.apache.lucene.analysis.Analyzer;
  import org.apache.lucene.index.IndexReader;
  import org.apache.lucene.index.IndexWriter;
  import org.apache.lucene.search.DelayCloseIndexSearcher;
  import org.apache.lucene.search.IndexSearcher;
  import org.apache.lucene.store.Directory;
  import org.apache.lucene.store.FSDirectory;
  import org.apache.lucene.store.RAMDirectory;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import com.atlassian.bonnie.search.SearcherInitialisation;
  
  /**
   * ILuceneConnection implementation that allows concurrent searching/reading and
   * writing/deleting. Concurrent writes and deletes block each other.
   * <p/>
   * This class optimizes use of Lucene reader instances by holding a common
   * IndexReader that is shared by idempotent operations on an unmodified index.
   * Any mutative operations cause the current IndexReader to be cleared, and
   * subsequent reads will see the results of the previous index change.
   * <p/>
   * TODO We might need to keep track of currently open readers and block
   * {@link #recreateIndexDirectory()} until they are all closed. We would also
   * need to prevent any new Readers being created during this time. The reason
   * for this is that Windows can throw exceptions when trying to move or
   * rename open files.
   */
  public class LuceneConnection implements ILuceneConnection
  {
      private static final Logger log = LoggerFactory.getLogger(LuceneConnection.class);
      
      private static final SearcherInitialisation NOOP_SEARCHER_INITIALISATION = new SearcherInitialisation() {
          public void initialise(IndexSearcher searcher) {}
      };
      
      /**
       * @deprecated since 3.2
       * @see #withWriter(WriterAction)
       */
      public static final int WRITER_DEFAULT = 0x01;
  
      /**
       * @deprecated since 3.2
       * @see #withWriter(WriterAction)
       */
      public static final int WRITER_INTERACTIVE = 0x02;
  
      /**
       * @deprecated since 3.2
       * @see #withWriter(WriterAction)
       */
      public static final int WRITER_BATCH = 0x04;
  
      private final Analyzer analyzerForIndexing;
  
      private final Configuration configuration;
  
      private final SearcherInitialisation searcherInitialisation;
  
      private final Lock indexWriteLock = new LoggingReentrantLock("indexWriteLock");
  
      private final Lock searcherRefreshLock = new LoggingReentrantLock("searcherRefreshLock");
      
      private final AtomicBoolean isClosed = new AtomicBoolean(false);
  
      /**
       * Used to indicate that we are currently in batchMode and need to use the batch configuration when using an
       * IndexWriter
       */
      private final AtomicBoolean batchMode = new AtomicBoolean(false);
  
      private volatile Directory directory;
  
      private volatile DelayCloseIndexSearcher searcher;
  
      public LuceneConnection(Directory directory, Analyzer analyzer, Configuration configuration, SearcherInitialisation searcherInitialisation)
      {
          this.directory = directory;
          this.analyzerForIndexing = analyzer;
          this.configuration = configuration;
          this.searcherInitialisation = searcherInitialisation;
          
          ensureIndexExists();
          searcher = createSearcher();
      }
  
      public LuceneConnection(Directory directory, Analyzer analyzer, Configuration configuration)
      {
          this(directory, analyzer, configuration, NOOP_SEARCHER_INITIALISATION);
      }
 
     public LuceneConnection(Directory directory, Analyzer analyzer)
     {
         this(directory, analyzer, DEFAULT_CONFIGURATION);
     }
     
     public LuceneConnection(File path, Analyzer analyzer, Configuration configuration, SearcherInitialisation searcherInitialisation)
     {
         this(getDirectory(path), analyzer, configuration, searcherInitialisation);
     }
 
     public LuceneConnection(File path, Analyzer analyzer, Configuration configuration)
     {
         this(getDirectory(path), analyzer, configuration);
     }
 
     public LuceneConnection(File path, Analyzer analyzer)
     {
         this(path, analyzer, DEFAULT_CONFIGURATION);
     }
     
     public int getNumDocs()
     {
         return (Integer) withReader(new ReaderAction() {
             public Object perform(IndexReader reader)
             {
                 return reader.numDocs();
             }
         });
     }
 
     /**
      * @deprecated since 3.2
      * @see ILuceneConnection#isIndexCreated()
      */
     public boolean isIndexCreated()
     {
         assertNotClosed();
         try
         {
             return IndexReader.indexExists(directory);
         }
         catch (IOException e)
         {
             throw new LuceneException(e);
         }
     }
 
     /**
      * @deprecated since 3.2
      * @see ILuceneConnection#leakSearcher()
      */
     public IndexSearcher leakSearcher()
     {
         assertNotClosed();
 
         // ensure we return the same searcher that we open
         DelayCloseIndexSearcher currentSearcher = searcher;
         currentSearcher.open();
         return currentSearcher;
     }
 
     /**
      * Blocks and waits until all write operations to the index complete. Optimizes the index while holding the write
      * lock to ensure no concurrent modifications. Optimize is done using interactive mode configuration.
      */
     public void optimize() throws LuceneException
     {
         withWriter(new WriterAction()
         {
             public void perform(IndexWriter writer) throws IOException
             {
                 writer.optimize();
             }
         });
     }
 
     /**
      * Blocks and waits until all write operations to the index complete. Recreates the index while holding the write
      * lock to ensure no concurrent modifications.
      */
     public void recreateIndexDirectory()
     {
         assertNotClosed();
         indexWriteLock.lock();
         try
         {
             /*
              * According to http://issues.apache.org/jira/browse/LUCENE-140 it is not sufficient to create an IndexWriter with the create flag, you need to
              * recreate the directory as well
              */
             directory.close();
             if (directory instanceof FSDirectory)
             {
                 directory = FSDirectory.getDirectory(((FSDirectory) directory).getFile());
             }
             else if (directory instanceof RAMDirectory)
             {
                 directory = new RAMDirectory();
             }
             
             // Pass 'true' for 'create' to the IndexWriter so that the index is
             // either:
             // - created if it does not exists
             // - or blown away and empty one recreated if index existed already
             new IndexWriter(directory, null, true).close();
             
             refreshSearcher();
         }
         catch (IOException e)
         {
             throw new LuceneException("Cannot create index directory: " + directory, e);
         }
         finally
         {
             indexWriteLock.unlock();
         }
     }
 
     public void close() throws LuceneException
     {
         assertNotClosed();
         try
         {
             searcher.closeWhenDone();
             isClosed.set(true);
         }
         catch (IOException e)
         {
             throw new LuceneException(e);
         }
     }
     
     private void assertNotClosed() throws LuceneException
     {
         if (isClosed.get())
             throw new LuceneConnectionClosedException("Cannot operate on closed " + getClass().getSimpleName());
     }
     
     /**
      * @deprecated since 3.2, use {@link #close()} instead. 
      */
     public void flushWriter() throws LuceneException
     {
         close();
     }
     
     /**
      * This implementation does not respect the boolean return of the of the
      * {@link ILuceneConnection.SearcherAction#perform(org.apache.lucene.search.IndexSearcher)} method
      */
     public void withSearch(SearcherAction action) throws LuceneException
     {
         assertNotClosed();
 
         // keep a reference to the searcher in case it changes before the end of the search
         DelayCloseIndexSearcher currentSearcher = searcher;
         currentSearcher.open();
         try
         {
             action.perform(currentSearcher);
         }
         catch (IOException e)
         {
             throw new LuceneException(e);
         }
         finally
         {
             closeSearcher(currentSearcher);
         }
     }
 
     public Object withReader(final ReaderAction action) throws LuceneException
     {
         final AtomicReference<Object> result = new AtomicReference<Object>();
         withSearch(new SearcherAction()
         {
             public void perform(IndexSearcher searcher) throws IOException
             {
                 result.set(action.perform(searcher.getIndexReader()));
             }
         });
         return result.get();
     }
 
     /**
      * Blocks and waits until all write operations to the index complete. Executes the ReaderAction while holding the
      * write lock to ensure no concurrent modifications.
      */
     public void withReaderAndDeletes(ReaderAction action) throws LuceneException
     {
         assertNotClosed();
         indexWriteLock.lock();
         try
         {
             IndexReader deleter = openReader();
             try
             {
                 action.perform(deleter);
             }
             catch (IOException e)
             {
                 throw new LuceneException(e);
             }
             finally
             {
                 closeReader(deleter);
             }
             // Only close the current searcher if the index update succeeded
             refreshSearcher();
         }
         finally
         {
             indexWriteLock.unlock();
         }
     }
 
     /**
      * Blocks and waits until all write operations to the index complete. Executes the WriterAction while holding the
      * write lock to ensure no concurrent modifications.
      */
     public void withWriter(WriterAction action) throws LuceneException
     {
         assertNotClosed();
         indexWriteLock.lock();
         try
         {
             IndexWriter writer = new IndexWriter(directory, analyzerForIndexing, false);
             configureIndexWriter(writer, configuration);
             try
             {
                 action.perform(writer);
             }
             catch (IOException e)
             {
                 throw new LuceneException(e);
             }
             finally
             {
                 closeWriter(writer);
             }
             // Only refresh the current searcher if the index update succeeded
             refreshSearcher();
         }
         catch (IOException e)
         {
             throw new LuceneException("Couldn't open writer on directory: " + directory, e);
         }
         finally
         {
             // Release the lock, no matter what.
             indexWriteLock.unlock();
         }
     }
 
     /**
      * @deprecated since 3.2 use {@link #withWriter(WriterAction)} for interactive writes, or
      * {@link #withBatchUpdate(BatchUpdateAction)} for batch writes.
      */
     public void withWriter(final WriterAction action, int flags) throws LuceneException
     {
         if (flags == WRITER_BATCH)
         {
             withBatchUpdate(new BatchUpdateAction() {
                 public void perform() throws Exception {
                     withWriter(action);
                 }
             });
         }
         else
         {
             withWriter(action);
         }
     }
 
     public void withDeleteAndWrites(ReaderAction readerAction, WriterAction writerAction) throws LuceneException
     {
         indexWriteLock.lock();
         try
         {
             withReaderAndDeletes(readerAction);
             withWriter(writerAction);
         }
         finally
         {
             indexWriteLock.unlock();
         }
     }
 
     /**
      * Blocks and waits until all write operations to the index complete. Executes the BatchUpdateAction while holding
      * the write lock to ensure no concurrent modifications. <p/> Note: This method holds the writeLock for the whole
      * operation, so is used to ensure a set of deletes and writes are effectively executed atomically.
      * <p/>
      * Refreshes the searcher only once, at the end of the batch update action.
      */
     public void withBatchUpdate(BatchUpdateAction action)
     {
         assertNotClosed();
         indexWriteLock.lock();
         try
         {
             batchMode.set(true);
             try
             {
                 action.perform();
             }
             catch (Exception e) // unfortunately, the API requires us to catch Exception here
             {
                 throw new LuceneException(e);
             }
             finally
             {
                 batchMode.set(false);
             }
             refreshSearcher();
         }
         finally
         {
             indexWriteLock.unlock();
         }
     }
 
     /**
      * Closes the searcher that is currently in use.
      * @deprecated since 3.2
      * @see #withWriter(WriterAction)
      * @see #withDeleteAndWrites(ReaderAction, WriterAction)
      * @see #withSearch(SearcherAction)
      */
     public void flipCurrentSearcher()
     {
         assertNotClosed();
         refreshSearcher();
     }
 
     /**
      * Marks the current searcher to be closed once all searches are finished,
      * and creates a new one for later searches.
      * <p/>
      * Doesn't refresh the searcher if a batch operation is in progress (i.e.
      * {@link #batchMode} is <tt>true</tt>.
      */
     private void refreshSearcher()
     {
         // don't refresh searcher during a batch operation
         if (batchMode.get()) 
             return; 
         
         searcherRefreshLock.lock();
         try
         {
             DelayCloseIndexSearcher oldSearcher = searcher;
             searcher = createSearcher();
 
             if (log.isDebugEnabled())
                 log.debug("Closing current searcher");
             try
             {
                 oldSearcher.closeWhenDone();
             }
             catch (IOException e)
             {
                 throw new LuceneException("Error closing index searcher", e);
             }
         }
         finally
         {
             searcherRefreshLock.unlock();
         }
     }
 
     /**
      * @return a newly created and initialised searcher
      */
     private DelayCloseIndexSearcher createSearcher() throws LuceneException
     {
         if (log.isDebugEnabled())
             log.debug("Creating new searcher");
         
         DelayCloseIndexSearcher searcher;
         try
         {
             searcher = new DelayCloseIndexSearcher(directory);
         }
         catch (IOException e)
         {
             throw new LuceneException("Failed to create searcher for directory: " + directory, e);
         }
         searcherInitialisation.initialise(searcher);
         return searcher;
     }
 
     private IndexReader openReader() throws LuceneException
     {
         try
         {
             return IndexReader.open(directory);
         }
         catch (IOException e)
         {
             throw new LuceneException(e);
         }
     }
 
     /**
      * Closes the provided reader and logs any exceptions.
      */
     private void closeReader(IndexReader reader)
     {
         if (reader == null)
             return;
 
         if (log.isDebugEnabled())
             log.debug("Closing index reader: " + reader.directory());
         try
         {
             reader.close();
         }
         catch (IOException e)
         {
             log.error("Error closing reader: " + reader.directory(), e);
         }
     }
 
     /**
      * Closes the provided searcher and logs any exceptions.
      */
     private void closeSearcher(IndexSearcher searcher)
     {
         if (searcher == null)
             return;
         try
         {
             searcher.close();
         }
         catch (IOException e)
         {
             log.error("Error occurred while closing searcher " + searcher.getIndexReader().directory(), e);
         }
     }
 
     /**
      * Closes the provided writer and logs any thrown exceptions without rethrowing them.
      */
     private void closeWriter(IndexWriter writer)
     {
         if (writer == null)
             return;
         
         if (log.isDebugEnabled())
             log.debug("Closing index writer " + writer.getDirectory());
         try
         {
             writer.close();
         }
         catch (IOException e)
         {
             log.error("Error closing writer " + writer.getDirectory(), e);
         }
     }
 
     private void configureIndexWriter(final IndexWriter indexWriter, Configuration configuration)
     {
         if (batchMode.get())
         {
             // using batchMode config
             indexWriter.setMaxBufferedDocs(configuration.getBatchMaxBufferedDocs());
             indexWriter.setMaxMergeDocs(configuration.getBatchMaxMergeDocs());
             indexWriter.setMergeFactor(configuration.getBatchMergeFactor());
         }
         else
         {
             // using interactiveMode config
             indexWriter.setMaxBufferedDocs(configuration.getInteractiveMaxBufferedDocs());
             indexWriter.setMaxMergeDocs(configuration.getInteractiveMaxMergeDocs());
             indexWriter.setMergeFactor(configuration.getInteractiveMergeFactor());
         }
         indexWriter.setMaxFieldLength(configuration.getMaxFieldLength());
         indexWriter.setUseCompoundFile(configuration.isCompoundIndexFileFormat());
     }
     
 	public void truncateIndex() throws LuceneException
     {
     	withReaderAndDeletes(new ILuceneConnection.ReaderAction() {
 			public Object perform(IndexReader reader) throws IOException {
                 for (int i = 0; i < reader.maxDoc(); i++) {
 		            reader.deleteDocument(i);
 		        }
 				return null;
 			}
     	});
     }
 	
 	/**
 	 * @deprecated since 3.2 because this class encapsulates the use of the index directory
 	 */
 	public File getIndexDir()
     {
 	    assertNotClosed();
 
         // keep a reference in case this changes
         Directory currentDirectory = directory;
         if (currentDirectory instanceof FSDirectory)
 	    {
 	        return ((FSDirectory) currentDirectory).getFile();
 	    }
 	    else
 	    {
 	        throw new UnsupportedOperationException("This " + this.getClass().getSimpleName() + " is not using a file system directory");
 	    }
     }
         
     /**
      * get a Directory from a path and don't throw a whingy bloody IOException
      */
     private static Directory getDirectory(File path)
     {
         try
         {
             if (!path.exists() && !path.mkdir())
             {
                 throw new IOException("Unable to create index directory '" + path.getAbsolutePath() + "'");
             }
             return FSDirectory.getDirectory(path);
         }
         catch (IOException e)
         {
             throw new LuceneException(e);
         }
     }
 
     /**
      * Ensures the index directory exists, contains a Lucene index, and is available
      * for writing.
      */
     private void ensureIndexExists()
     {
         indexWriteLock.lock();
         try
         {
             if (!IndexReader.indexExists(directory))
             {
                 new IndexWriter(directory, null, true).close();
             }
             
             if (IndexReader.isLocked(directory))
             {
                 // happens if the index was locked by a process which then died (or is still running -- hence the warning)
                 log.warn("Forcing unlock of locked index directory: " + directory);
                 IndexReader.unlock(directory);
             }
         }
         catch (IOException e)
         {
             throw new LuceneException("Cannot create index directory", e);
         }
         finally
         {
             indexWriteLock.unlock();
         }
     }
 }