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.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/>
   */
  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) {}
      };
      
      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 IndexWriter writer;
  
      private volatile DelayCloseIndexSearcher searcher;
  
      public LuceneConnection(Directory directory, Analyzer analyzer, Configuration configuration, final SearcherInitialisation searcherInitialisation)
      {
          this.analyzerForIndexing = analyzer;
          this.configuration = configuration;
          this.searcherInitialisation = searcherInitialisation;
          
          ensureIndexExists(directory);
          try
          {
              this.writer = new IndexWriter(directory, analyzerForIndexing, false);
          }
          catch (IOException e)
          {
              throw new LuceneException(e);
          }
  
          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();
             }
         });
     }
 
     /**
      * 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();
             }
         });
     }
 
     public void close() throws LuceneException
     {
         assertNotClosed();
         try
         {
             searcher.closeWhenDone();
             writer.close();
             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());
     }
     
     /**
      * 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 WriterAction while holding the
      * write lock to ensure no concurrent modifications.
      */
     public void withWriter(WriterAction action) throws LuceneException
     {
         assertNotClosed();
         indexWriteLock.lock();
         try
         {
             configureIndexWriter(writer, configuration);
             try
             {
                 action.perform(writer);
             }
             catch (IOException e)
             {
                 throw new LuceneException(e);
             }
             // Only refresh the current searcher if the index update succeeded
             commitAndRefreshSearcher();
         }
         finally
         {
             // Release the lock, no matter what.
             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);
             }
             commitAndRefreshSearcher();
         }
         finally
         {
             indexWriteLock.unlock();
         }
     }
 
     /**
      * 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 commitAndRefreshSearcher()
     {
         // don't refresh searcher during a batch operation
         if (batchMode.get())
             return;
 
         searcherRefreshLock.lock();
         try
         {
             DelayCloseIndexSearcher oldSearcher = searcher;
             writer.commit();
             searcher = createSearcher();
 
             if (log.isDebugEnabled())
                 log.debug("Closing current searcher");
 
             oldSearcher.closeWhenDone();
         }
         catch (IOException e)
         {
             throw new LuceneException("Error refreshing 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(writer.getReader());
             searcherInitialisation.initialise(searcher);
         }
         catch (IOException e)
         {
             throw new LuceneException("Failed to create searcher for directory: ", e);
         }
         return searcher;
     }
 
     /**
      * 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
     {
     	withWriter(new ILuceneConnection.WriterAction()
         {
             public void perform(IndexWriter writer) throws IOException
             {
                 writer.deleteAll();
             }
         });
     }
 	
     /**
      * 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(Directory directory)
     {
         indexWriteLock.lock();
         try
         {
             if (!IndexReader.indexExists(directory))
             {
                 new IndexWriter(directory, null, true).close();
             }
             
             if (IndexWriter.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);
                 IndexWriter.unlock(directory);
             }
         }
         catch (IOException e)
         {
             throw new LuceneException("Cannot create index directory", e);
         }
         finally
         {
             indexWriteLock.unlock();
         }
     }
 }