/*
    * 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.File;
  import java.util.Calendar;
  import java.util.Date;
  import java.util.Timer;
  import java.util.TimerTask;
  
  import net.sf.mmapps.modules.cloudprovider.CloudProvider;
  import net.sf.mmapps.modules.cloudprovider.CloudProviderFactory;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.mmbase.bridge.Cloud;
  import org.mmbase.bridge.CloudContext;
  import org.mmbase.bridge.ContextProvider;
  import org.mmbase.module.Module;
  import org.mmbase.module.core.MMBase;
  import org.mmbase.module.core.MMBaseContext;
  
  /***
   * This module enables the Lucene fulltext search engine to be used to index the MMBase cloud.
   * 
   * @author Wouter Heijke
   * @version $Revision: 1.2 $
   */
  public class LuceneModule extends Module {
      private static Log log = LogFactory.getLog(LuceneModule.class);
      
      private static CloudProvider cloudProvider = CloudProviderFactory.getCloudProvider();
  
      // timer to schedule the indexing
      private static Timer timer = null;
  
      // Milliseconds how long the thread will sleep
      private long interval;
  
      private int startHour;
  
      // Should we index on startup, default is true
      private boolean indexOnStartup = true;
  
      private String configFile = "lucenemodule.xml";
  
      private LuceneManager config = null;
  
      private String configroot;
  
      /*** The mmbase instance */
      private MMBase mmb = null;
  
      /***
       * Number of tries to get cloud. A second between each try.
       */
      private static final int GETCLOUD_NUM_OF_TRIES = 60;
  
      /***
       * Time to waite between tries.
       */
      private static final long GETCLOUD_INTERVAL_TRIES = 1000L;
  
      /***
       * Number of seconds to wait before starting on-startup-index.
       */
      private Integer onStartupWait = null;
  
      /***
       * @see org.mmbase.module.Module#onload()
       */
      public void onload() {
          // implement
      }
  
      /***
       * @see org.mmbase.module.Module#init()
       */
      public void init() {
          // Wait for mmbase to be up and running.
          // MMBase.getMMBase();
          mmb = (MMBase) Module.getModule("mmbaseroot");
  
          // Initialize the module.
          String intervalStr = getInitParameter("interval");
          if (intervalStr == null) {
              throw new IllegalArgumentException("interval");
          } else {
             interval = Long.parseLong(intervalStr) * 1000L * 60L;
         }
 
         String startHourStr = getInitParameter("starthour");
         if (startHourStr == null) {
             throw new IllegalArgumentException("starthour");
         } else {
             startHour = Integer.parseInt(startHourStr);
         }
 
         // If there is a init paramater index-on-startup use it (default: false)
         String indexOnStartupStr = getInitParameter("index-on-startup");
         if (indexOnStartupStr != null) {
             indexOnStartup = Boolean.valueOf(indexOnStartupStr).booleanValue();
         } else {
             log.warn("index-on-startup property not set");
         }
 
         String onStartupWaitStr = getInitParameter("index-on-startup-wait");
         if (onStartupWaitStr != null) {
             onStartupWait = new Integer(onStartupWaitStr);
         }
 
         String userConfigFile = getInitParameter("configfile");
         if (userConfigFile == null) {
             throw new IllegalArgumentException("configfile");
         } else {
             configFile = userConfigFile;
         }
 
         config = new LuceneManager();
 
         configroot = MMBaseContext.getConfigPath();
 
         config.readConfig(configroot + File.separator + configFile);
 
         // index just once if indexOnStartup is true
         if (indexOnStartup) {
             Thread runOnce = new Thread(new IndexingTimerTask());
             runOnce.setDaemon(true);
             runOnce.start();
         }
 
         // Create a new Timer object; true for daemon
         timer = new Timer(true);
 
         // Get the current date and set the time to startHour
         Calendar cal = Calendar.getInstance();
         cal.set(Calendar.HOUR_OF_DAY, startHour);
         cal.set(Calendar.MINUTE, 0);
         cal.set(Calendar.SECOND, 0);
 
         // If the current date is after startHour then add one day
         if (Calendar.getInstance().after(cal)) {
             cal.add(Calendar.DAY_OF_YEAR, 1);
         }
         Date time = cal.getTime();
 
         // Schedule the actual thread at startHour with a period of interval
         timer.scheduleAtFixedRate(new IndexingTimerTask(), time, interval);
     }
 
     private class IndexingTimerTask extends TimerTask {
         /***
          * The thread in which the external links will be checked
          */
         public void run() {
             if (onStartupWait != null) {
                 log.debug("LuceneModule waiting for " + onStartupWait + " seconds");
                 try {
                     Thread.sleep(onStartupWait.intValue() * 1000L);
                 } catch (InterruptedException e) {
                     // ignore
                 }
                 // only wait the first time
                 onStartupWait = null;
             }
 
             log.info("LuceneModule thread started");
             startIndexing();
         }
     }
 
     public LuceneManager getLuceneManager() {
         return config;
     }
 
     /***
      * Start indexing the cloud after MMBase has really started.
      */
     private void startIndexing() {
         try {
             while (!mmb.hasStarted()) {
                 // not started, sleep another minute
                 Thread.sleep(60000);
             }
         } catch (InterruptedException e) {
         }
         Cloud cloud = getCloud();
 
         log.info("LuceneModule start indexing");
         config.collectAll(cloud);
     }
 
     /***
      * Get a cloud reference. Wait for one if no reference available yet.
      * 
      * @return a cloud reference
      * @throws RuntimeException when timed out
      */
     public Cloud getCloud() {
         RuntimeException lastEx = null;
         for (int i = 0; i < GETCLOUD_NUM_OF_TRIES; i++) {
             try {
                 return cloudProvider.getCloud();
             } catch (RuntimeException ex) {
                 lastEx = ex;
                 try {
                     Thread.sleep(GETCLOUD_INTERVAL_TRIES);
                 } catch (InterruptedException e) {
                     // ignore
                 }
             }
         }
 
         log.error("can't get cloud: " + lastEx);
         throw lastEx == null ? new RuntimeException("can't get cloud") : lastEx;
     }
 }