/*
    * MMBase Lucene module
    *
    * The contents of this file are subject to the Mozilla Public License
    * Version 1.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.mozilla.org/MPL/
    *
    * Software distributed under the License is distributed on an "AS IS"
   * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
   * License for the specific language governing rights and limitations
   * under the License.
   */
  package net.sf.mmapps.modules.lucenesearch;
  
  import java.io.IOException;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.apache.lucene.analysis.Analyzer;
  import org.apache.lucene.analysis.standard.StandardAnalyzer;
  import org.apache.lucene.document.Document;
  import org.apache.lucene.index.IndexReader;
  import org.apache.lucene.index.IndexWriter;
  import org.apache.lucene.index.Term;
  import org.apache.lucene.search.IndexSearcher;
  
  /***
   * This object handles access to Lucene indexes
   * 
   * @author Wouter Heijke
   * @version $Revision: 1.1 $
   */
  public class IndexHelper {
      private static Log log = LogFactory.getLog(IndexHelper.class);
  
      private IndexWriter writer;
  
      private Analyzer analyzer = new StandardAnalyzer();
  
      private String indexName;
  
      /***
       * Constructor for the IndexHelper object
       */
      public IndexHelper() {
          log.debug("IndexHelper started");
      }
  
      /***
       * Sets the analyzer attribute of the IndexHelper object
       * 
       * @param a The new analyzer value
       */
      public void setAnalyzer(Analyzer a) {
          this.analyzer = a;
      }
  
      /***
       * Sets the indexName attribute of the IndexHelper object
       * 
       * @param name The new indexName value
       */
      public void setIndexName(String name) {
          this.indexName = name;
      }
  
      /***
       * Returns the name of the index
       * 
       * @return Returns the indexName.
       */
      public String getIndexName() {
          return indexName;
      }
  
      /***
       * Create the index (writer)
       * 
       * @param name
       * @param analyzer
       */
      public void create(String name, Analyzer analyzer) {
          log.debug("creating Lucene storage with index name '" + name + "'");
          setAnalyzer(analyzer);
          setIndexName(name);
          open(true);
      }
  
      /***
       * Open the writer
       */
      public void open() {
          log.debug("opening Lucene storage with index name '" + indexName + "'");
          open(false);
      }
  
      /***
       * Close the writer
      */
     public void close() {
         log.debug("closing Lucene storage with index name '" + indexName + "'");
         try {
             writer.optimize();
             writer.close();
             writer = null;
         } catch (IOException e) {
             log.error("IOException occured when closing Lucene Index with index name '" + indexName + "'");
             e.printStackTrace();
         }
     }
 
     /***
      * Write a Lucene Document to the index
      * 
      * @param document Lucene Document
      */
     public void write(Document document) {
         try {
             writer.addDocument(document);
         } catch (IOException e) {
             log.error("IOException occured when writing document to Lucene Index with index name '" + indexName + "'");
             e.printStackTrace();
         }
     }
 
     /***
      * Return the amount of documents in the index when writing to it.
      * 
      * @return -1 if no size or the amount of documents in the index
      */
     public int size() {
         int result = -1;
         if (writer != null) {
             result = writer.docCount();
         }
         return result;
     }
 
     /***
      * Returns the IndexSearcher for this index
      * 
      * @return IndexSearcher
      */
     public IndexSearcher getSearcher() {
         IndexSearcher result = null;
         try {
             result = new IndexSearcher(indexName);
         } catch (IOException e) {
             log.error("IOException occured when opening Lucene Index with index name '" + indexName + "' for searching");
             e.printStackTrace();
         }
         return result;
     }
 
     /***
      * Returns the IndexReader for this index
      * 
      * @return IndexReader
      */
     private IndexReader getReader() {
         IndexReader result = null;
         try {
             result = IndexReader.open(indexName);
         } catch (IOException e) {
             log.error("IOException occured when opening Lucene Index with index name '" + indexName + "' for reading");
             e.printStackTrace();
         }
         return result;
     }
 
     /***
      * Delete a document from the index
      * 
      * @param term A Lucene Term describing the document to delete
      * @return Amount of deleted documents
      */
     public int delete(Term term) {
         int result = -1;
         try {
             IndexReader reader = getReader();
             result = reader.delete(term);
             reader.close();
         } catch (IOException e) {
             log.error("IOException occured when deleting a document from Lucene Index with index name '" + indexName + "'");
             e.printStackTrace();
         }
         return result;
     }
 
     /***
      * Open the index for writing
      * 
      * @param create Open for update (false) or a clean new index (true)
      */
     private void open(boolean create) {
         try {
             writer = new IndexWriter(indexName, analyzer, create);
         } catch (IOException e) {
             log.error("IOException occured when opening Lucene Index with index name '" + indexName + "' for writing");
             e.printStackTrace();
         }
         if (writer != null) {
             log.debug("lucene storage opened successfully");
         }
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see java.lang.Object#finalize()
      */
     protected void finalize() throws Throwable {
         log.debug("finalize on index name '" + indexName + "'");
         try {
             writer.close();
         } finally {
             super.finalize();
         }
     }
 }