package com.atlassian.bonnie;
   
   import edu.emory.mathcs.backport.java.util.concurrent.locks.ReadWriteLock;
   import edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock;
   import org.apache.log4j.Category;
   import org.apache.log4j.Level;
   import org.apache.lucene.analysis.Analyzer;
   import org.apache.lucene.index.IndexReader;
   import org.apache.lucene.index.IndexUtils;
  import org.apache.lucene.index.IndexWriter;
  import org.apache.lucene.search.IndexSearcher;
  import org.apache.lucene.store.Directory;
  import org.apache.lucene.store.FSDirectory;
  
  import java.io.File;
  import java.io.FileNotFoundException;
  import java.io.IOException;
  
  /**
   * TODO reentrancy to/from reader/writer ... allow it?
   * these operations can occur concurrently, using the same reader (writer closed beforehand):
   * - withSearch
   * - withReader
   * <p/>
   * these operations will be serialized against all other operatons
   * - withWriter (closes any readers closed beforehand)
   * - withReaderAndDeletes (writers closed beforehand, reader+writer closed afterwards)
   * - optimize (any readers closed beforehand)
   * - flushWriter (closes readers and writers)
   * <p/>
   * also see:
   * - "What are all possible concurrent Lucene requests?" http://www.jguru.com/faq/view.jsp?EID=913302
   *
   * @author Matt Quail
   */
  public class LuceneConnection implements ILuceneConnection
  {
      public static final Category LOG = Category.getInstance(LuceneConnection.class);
  
      public static final int WRITER_DEFAULT = 0x01;
      public static final int WRITER_INTERACTIVE = 0x02;
      public static final int WRITER_BATCH = 0x04;
  
      public static final String REINDEXING_FILENAME = ".reindexing";
  
      protected Analyzer analyzerForIndexing;
      protected boolean searcherOpensNewReader = true;
  
      private File indexDir = null;
  
      /**
       * The directory that contains the lucene index.
       */
      private Directory directory = null;
  
      private final ReadWriteLock sync = new ReentrantReadWriteLock();
      private final Object createLock = new Object();
  
      private final Configuration configuration;
  
      private IndexReader reader = null;
      private IndexWriter writer = null;
  
      private long readerVersion = -1;
      private boolean alwaysUnlock = true;
  
  
      /**
       * Default constructor.
       */
      public LuceneConnection()
      {
          this.configuration = DEFAULT_CONFIGURATION;
      }
  
      /**
       * Create a new lucene connection, setting the index directory to be the specified location.
       *
       * @param location of the index directory.
       *
       * @param analyzerForIndexing
       */
      public LuceneConnection(File location, Analyzer analyzerForIndexing)
      {
          this(location, analyzerForIndexing, DEFAULT_CONFIGURATION);
      }
      /**
       * Create a new lucene connection, setting the index directory to be the specified location.
       *
       * @param location of the index directory.
       * @param analyzerForIndexing
       * @param configuration of the Lucene IndexWriter settings
       */
      public LuceneConnection(File location, Analyzer analyzerForIndexing, Configuration configuration)
      {
          this.indexDir = location;
          this.analyzerForIndexing = analyzerForIndexing;
          this.configuration = configuration;
      }
 
     /**
      * Create a new lucene connection, setting the index directory to be the specified directory.
      *
      * @param directory used for storing the lucene index.
      * @param analyzerForIndexing
      */
     public LuceneConnection(Directory directory, Analyzer analyzerForIndexing)
     {
         this.directory = directory;
         this.analyzerForIndexing = analyzerForIndexing;
         this.configuration = DEFAULT_CONFIGURATION;
     }
 
     /**
      * Create a new lucene connection, setting the index directory to be the specified directory.
      *
      * @param directory used for storing the lucene index.
      * @param analyzerForIndexing
      * @param configuration of the Lucene IndexWriter settings
      */
     public LuceneConnection(Directory directory, Analyzer analyzerForIndexing, Configuration configuration)
     {
         this.directory = directory;
         this.analyzerForIndexing = analyzerForIndexing;
         this.configuration = configuration;
     }
 
     /*
      * @see com.atlassian.bonnie.ILuceneConnection#withSearch(com.atlassian.bonnie.LuceneConnection.SearcherAction)
      */
     public void withSearch(LuceneConnection.SearcherAction action) throws LuceneException
     {
         IndexSearcher searcher = null;
         grabReadLock();
         try
         {
             searcher = getSearcher();
             if (action.perform(searcher))
             {
                 searcher.close();
             }
         }
         catch (Throwable e)
         {
             if (searcher != null)
             {
                 try
                 {
                     searcher.close();
                 }
                 catch (Throwable t)
                 {
                     LOG.debug(t);
                 }
             }
             if (e instanceof Error)
             {
                 throw (Error) e;
             }
             if (e instanceof RuntimeException)
             {
                 throw (RuntimeException) e;
             }
             throw new LuceneException(e);
         }
         finally
         {
             releaseReadLock();
         }
     }
 
     protected IndexSearcher getSearcher() throws IOException
     {
         if (searcherOpensNewReader)
         {
             return new IndexSearcher(getDirectory());
         }
         else
         {
             return new IndexSearcher(getReader());
         }
     }
 
     /*
      * @see com.atlassian.bonnie.ILuceneConnection#withReader(com.atlassian.bonnie.LuceneConnection.ReaderAction)
      */
     public Object withReader(LuceneConnection.ReaderAction action) throws LuceneException
     {
         Object result = null;
         grabReadLock();
         try
         {
             IndexReader reader = getReader();
             result = action.perform(reader);
         }
         catch (IOException e)
         {
             throw new LuceneException(e);
         }
         finally
         {
             releaseReadLock();
         }
         return result;
     }
 
     /*
      * @see com.atlassian.bonnie.ILuceneConnection#withReaderAndDeletes(com.atlassian.bonnie.LuceneConnection.ReaderAction)
      */
     public void withReaderAndDeletes(ReaderAction action) throws LuceneException
     {
         grabWriteLock();
         try
         {
             unlockIfNeeded();
             closeWriter();
             IndexReader reader = getReader();
             action.perform(reader);
             closeReader();
         }
         catch (IOException e)
         {
             //TODO invalidate reader/write on any exception
             throw new LuceneException(e);
         }
         finally
         {
             releaseWriteLock();
         }
     }
 
     /*
      * @see com.atlassian.bonnie.ILuceneConnection#withWriter(com.atlassian.bonnie.LuceneConnection.WriterAction)
      */
     public void withWriter(WriterAction action) throws LuceneException
     {
         withWriter(action, WRITER_INTERACTIVE);
     }
 
     public void withWriter(WriterAction action, int flags) throws LuceneException
     {
         grabWriteLock();
         try
         {
             unlockIfNeeded();
             IndexWriter writer = getWriter(flags);
             action.perform(writer);
             if (!isReIndexing())
             {
                 closeWriter();
             }
         }
         catch (IOException e)
         {
             throw new LuceneException(e);
         }
         finally
         {
             releaseWriteLock();
         }
     }
     
     public void withDeleteAndWrites(ReaderAction readerAction, WriterAction writerAction) throws LuceneException
     {
         grabWriteLock();
         try
         {
             withReaderAndDeletes(readerAction);
             withWriter(writerAction);
         }
         finally
         {
         	releaseWriteLock();
         }
     }
 
     /*
      * @see com.atlassian.bonnie.ILuceneConnection#withBatchUpdate(com.atlassian.bonnie.LuceneConnection.BatchUpdateAction)
      */
     public void withBatchUpdate(BatchUpdateAction action)
     {
         grabWriteLock();
         try
         {
             action.perform();
         }
         catch (Exception e)
         {
             throw new LuceneException(e);
         }
         finally
         {
             releaseWriteLock();
         }
     }
 
     /*
      * @see com.atlassian.bonnie.ILuceneConnection#optimize()
      */
     public void optimize() throws LuceneException
     {
         grabWriteLock();
         try
         {
             IndexWriter writer = getWriter();
             writer.optimize();
             closeWriter();
         }
         catch (IOException e)
         {
             throw new LuceneException(e);
         }
         finally
         {
             releaseWriteLock();
         }
     }
 
     public void setSearcherOpensNewReader(boolean searcherOpensNewReader)
     {
         this.searcherOpensNewReader = searcherOpensNewReader;
     }
 
     private IndexWriter createAndConfigureWriter(int flags) throws LuceneException
     {
         try
         {
             if (LOG.isDebugEnabled())
             {
                 LOG.debug(Thread.currentThread().getName() + "## opening writer");
             }
             IndexWriter writer = new IndexWriter(getDirectory(), analyzerForIndexing, false);
             configureWriter(writer, flags);
             return writer;
         }
         catch (IOException e)
         {
             throw new LuceneException(e);
         }
     }
 
     /**
      * Configures a writer according to our particular requirements.
      * See http://marc.theaimsgroup.com/?l=lucene-user&m=110235452004799&w=2 for more details
      */
     void configureWriter(IndexWriter writer, int flags)
     {
         writer.setMaxFieldLength(configuration.getMaxFieldLength());
         writer.setUseCompoundFile(configuration.isCompoundIndexFileFormat());
         if (isSet(flags, WRITER_BATCH))
         {
             writer.setMergeFactor(configuration.getBatchMergeFactor());
             writer.setMaxBufferedDocs(configuration.getBatchMaxBufferedDocs());
             writer.setMaxMergeDocs(configuration.getBatchMaxMergeDocs());
         }
         else if (isSet(flags, WRITER_INTERACTIVE))
         {
             writer.setMergeFactor(configuration.getInteractiveMergeFactor());
             writer.setMaxBufferedDocs(configuration.getInteractiveMaxBufferedDocs());
             writer.setMaxMergeDocs(configuration.getInteractiveMaxMergeDocs());
         }
     }
 
     private static boolean isSet(int flags, int f)
     {
         return (flags & f) > 0;
     }
 
     public void flushWriter() throws LuceneException
     {
         grabWriteLock();
         try
         {
             closeReader();
             closeWriter();
         }
         finally
         {
             releaseWriteLock();
         }
     }
 
     protected final IndexReader getReader() throws LuceneException
     {
         synchronized (createLock)
         {
 //            closeWriter();
             try
             {
                 if (reader == null)
                 {
                     createIndexDirectory(false);
                     LOG.debug(Thread.currentThread().getName() + "##opening reader");
                     readerVersion = IndexReader.getCurrentVersion(getDirectory());
                     reader = IndexReader.open(getDirectory());
                 }
                 else
                 {
                     long v = IndexReader.getCurrentVersion(getDirectory());
                     if (v != readerVersion)
                     {
                         createIndexDirectory(false);
                         LOG.debug(Thread.currentThread().getName() + "Refreshing reader");
                         // if current version for directory is difference from existing version in reader, then
                         // close the reader and open a new one.
                         reader.close();
                         reader = IndexReader.open(getDirectory());
                         readerVersion = v;
                     }
                 }
                 return reader;
             }
             catch (IOException e)
             {
                 throw new LuceneException(e);
             }
         }
     }
 
     protected IndexWriter getWriter() throws LuceneException
     {
         return getWriter(WRITER_DEFAULT);
     }
 
     protected IndexWriter getWriter(int flags) throws LuceneException
     {
         synchronized (createLock)
         {
             createIndexDirectory(false);
             closeReader();
             if (writer == null)
             {
                 writer = createAndConfigureWriter(flags);
             }
             return writer;
         }
     }
 
     /**
      * you must have a write-lock to call this method
      */
     private void closeWriter()
     {
         synchronized (createLock)
         {
             if (writer != null)
             {
                 try
                 {
                     IndexWriter writer = this.writer;
                     this.writer = null;
                     if (LOG.isDebugEnabled())
                     {
                         LOG.debug(Thread.currentThread().getName() + "##closing writer");
                     }
                     writer.close();
                 }
                 catch (IOException e)
                 {
                     LOG.error(Level.ERROR + "problem closing index writer" + e, e);
                 }
             }
         }
     }
 
     /**
      * you must have a write-lock to call this method
      */
     private void closeReader()
     {
         synchronized (createLock)
         {
             if (reader != null)
             {
                 try
                 {
                     IndexReader reader = this.reader;
                     this.reader = null;
                     if (LOG.isDebugEnabled())
                     {
                         LOG.debug(Thread.currentThread().getName() + "##closing reader");
                     }
                     reader.close();
                 }
                 catch (IOException e)
                 {
                     LOG.error("problem closing index reader" + e, e);
                 }
             }
         }
     }
 
     private void grabReadLock() throws LuceneException
     {
         sync.readLock().lock();
     }
 
     private void releaseReadLock()
     {
         sync.readLock().unlock();
     }
 
     private void grabWriteLock() throws LuceneException
     {
         sync.writeLock().lock();
     }
 
     private void releaseWriteLock()
     {
         sync.writeLock().unlock();
     }
 
     /*
      * @see com.atlassian.bonnie.ILuceneConnection#close()
      */
     public void close()
     {
         try
         {
             grabWriteLock();
             try
             {
                 closeReader();
                 closeWriter();
             }
             finally
             {
                 releaseWriteLock();
             }
         }
         catch (LuceneException e)
         {
             LOG.error("problem closing lucene connection" + e);
         }
     }
 
     public boolean isReIndexing() throws IOException
     {
         return getDirectory().fileExists(REINDEXING_FILENAME);
     }
 
     /**
      * Sets reindexing flag. This is NOT a simple setter method. If true,
      * the index's timestamp is updated and a .reindexing file is created as a flag.
      * If false, the .reindexing file is deleted and the writer is closed.
      *
      * @param b
      * @throws IOException
      */
     public void setReIndexing(boolean b) throws IOException
     {
         if (!b)
         {
             if (isReIndexing())
             {
                 getDirectory().deleteFile(REINDEXING_FILENAME);
                 closeWriter();
             }
         }
         else if (!isReIndexing())
         {
             Directory directory = getDirectory();
             if (!directory.fileExists(REINDEXING_FILENAME))
             {
                 directory.createOutput(REINDEXING_FILENAME).close();
             }
             else
             {
                 directory.touchFile(REINDEXING_FILENAME);
             }
         }
     }
 
     public void recreateIndexDirectory()
     {
         createIndexDirectory(true);
     }
 
     public IndexSearcher leakSearcher()
     {
         throw new UnsupportedOperationException("Not Implemented. Use withSearch method instead.");
     }
 
     /**
      * Returns true if the index directory should be created. This implementation will return true if and only if the index
      * does not already exist.
      *
      * @return
      *
      * @throws IOException
      */
     protected boolean shouldCreateIndexDirectory() throws IOException
     {
         return !isIndexCreated();
     }
 
     /**
      * Create the lucene index. Note: If the index directory already exists AND forceCreate is true, then the existing
      * index will be deleted and a new one created. If forceCreate is false, then a new index is created iff the index
      * does not already exist.
      *
      * @param forceCreate if you want a new index to be created.
      */
     private void createIndexDirectory(boolean forceCreate)
     {
         try
         {
             if (forceCreate || (shouldCreateIndexDirectory()))
             {
                 // this will create a new directory (and erase the old if it exists)
                 new IndexWriter(getDirectory(), null, true).close();
             }
         }
         catch (IOException e)
         {
             throw new LuceneException("Cannot create index directory", e);
         }
     }
 
     public void truncateIndex() throws IOException
     {
         grabWriteLock();
 
         try
         {
             IndexUtils.truncateIndex(getDirectory());
         }
         catch(FileNotFoundException e)
         {
             // the index probably doesn't exist or is corrupt. just recreate it then
             recreateIndexDirectory();
         }
         finally
         {
             releaseWriteLock();
         }
     }
 
     /**
      *
      * @return
      * @throws IOException
      */
     protected Directory getDirectory() throws IOException
     {
         if (directory == null)
         {
             File indexDir = getIndexDir();
             if (!indexDir.exists() && !indexDir.mkdir())
             {
                 throw new IOException("Unable to create index directory '" + indexDir.getAbsolutePath() + "'");
             }
             directory = FSDirectory.getDirectory(indexDir);
         }
         return directory;
     }
 
     public File getIndexDir()
     {
         return indexDir;
     }
 
     public void setIndexDir(String location)
     {
         this.indexDir = new File(location);
     }
 
     /*
      * @see com.atlassian.bonnie.ILuceneConnection#getNumDocs()
      */
     public int getNumDocs()
     {
         int count = -1;
         try
         {
             grabReadLock();
             count = getReader().numDocs();
         }
         finally
         {
             releaseReadLock();
         }
         return count;
     }
 
     /*
      * @see com.atlassian.bonnie.ILuceneConnection#isIndexCreated()
      */
     public boolean isIndexCreated()
     {
         try
         {
             return IndexReader.indexExists(getDirectory());
         }
         catch (IOException e)
         {
             return false;
         }
     }
 
     public void unlockIfNeeded() throws IOException
     {
         if (alwaysUnlock)
         {
             IndexReader.unlock(getDirectory());
         }
     }
 
     public void setAlwaysUnlock(boolean alwaysUnlock)
     {
         this.alwaysUnlock = alwaysUnlock;
     }
 
     public class TempIndexWriterData
     {
         public final IndexWriter writer;
         public final Directory dir;
         public final File tmpIndexDir;
 
         public TempIndexWriterData(IndexWriter writer, Directory dir, File tmpIndexDir)
         {
             this.writer = writer;
             this.dir = dir;
             this.tmpIndexDir = tmpIndexDir;
         }
     }
 }