/*
 * $Header: /cvsroot/mvnforum/mvnforum/src/com/mvnforum/search/company/CompanyIndexer.java,v 1.14 2005/01/18 11:52:21 minhnn Exp $
 * $Author: minhnn $
 * $Revision: 1.14 $
 * $Date: 2005/01/18 11:52:21 $
 *
 * ====================================================================
 *
 * Copyright (C) 2002-2005 by MyVietnam.net
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or any later version.
 *
 * All copyright notices regarding mvnForum MUST remain intact
 * in the scripts and in the outputted HTML.
 * The "powered by" text/logo with a link back to
 * http://www.mvnForum.com and http://www.MyVietnam.net in the
 * footer of the pages MUST remain visible when the pages
 * are viewed on the internet or intranet.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 * Support can be obtained from support forums at:
 * http://www.mvnForum.com/mvnforum/index
 *
 * Correspondence and Marketing Questions can be sent to:
 * info@MyVietnam.net
 *
 * @author: Minh Nguyen  minhnn@MyVietnam.net
 * @author: Dejan Krsmanovic dejan_krsmanovic@yahoo.com
 */
package com.mvnforum.search.company;

import java.io.IOException;

import com.mvnforum.MVNForumConfig;
import com.mvnforum.MVNForumFactoryConfig;
import com.mvnforum.db.CompanyBean;
import net.myvietnam.mvncore.exception.SearchException;
import net.myvietnam.mvncore.util.DateUtil;
import net.myvietnam.mvncore.util.TimerUtil;
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.*;
import org.apache.lucene.index.*;
import org.apache.lucene.search.IndexSearcher;

public class CompanyIndexer
{
    private static Log log = LogFactory.getLog(CompanyIndexer.class);

    //Field names (used for indexing)
    public static final String FIELD_COMPANY_ID       = "CompanyID";
    public static final String FIELD_COMPANY_NAME     = "CompanyName";
    public static final String FIELD_COMPANY_ADDRESS  = "companyAddress";
    public static final String FIELD_CREATION_DATE    = "CompanyCreationDate";
    public static final String FIELD_MODIFIED_DATE    = "CompanyModifiedDate";

    //public static final String PROPERTY_SEARCH_PATH      = "search.path";
    //public static final String PROPERTY_SEARCH_AUTOINDEX = "search.autoindex";

    //Timer is used for scheduling jobs
    private static Analyzer analyzer;
    private static String searchCompanyIndexDir;

    private static long lastOptimizeTime = 0;

    static {
        searchCompanyIndexDir = MVNForumConfig.getSearchCompanyIndexDir();
        initializeAnalyzer();
    }

    public static void scheduleAddCompanyTask(CompanyBean companyBean) {
        AddUpdateCompanyIndexTask task = new AddUpdateCompanyIndexTask(companyBean, AddUpdateCompanyIndexTask.OPERATION_ADD);
        TimerUtil.getInstance().schedule(task, 0);
    }

    public static void scheduleUpdateCompanyTask(CompanyBean companyBean) {
        AddUpdateCompanyIndexTask task = new AddUpdateCompanyIndexTask(companyBean, AddUpdateCompanyIndexTask.OPERATION_UPDATE);
        TimerUtil.getInstance().schedule(task, 0);
    }

    public static void scheduleDeleteCompanyTask(int objectID) {
        DeleteCompanyIndexTask task = new DeleteCompanyIndexTask(objectID);
        TimerUtil.getInstance().schedule(task, 0);
    }

    public static void scheduleRebuildIndexTask() {
        RebuildCompanyIndexTask task = new RebuildCompanyIndexTask();
        TimerUtil.getInstance().schedule(task, 0);
    }

    static Analyzer getAnalyzer() {
        return analyzer;
    }

    /**
     * This class will load analyzer when starting. If specified analyzer class
     * cannot be loaded then default analyzer will be used.
     */
    private static void initializeAnalyzer() {
        String analyzerClassName = MVNForumFactoryConfig.getLuceneAnalyzerClassName();
        if ( (analyzerClassName == null) || (analyzerClassName.equals("")) ) {
            //create standard analyzer
            //String[] stopWords = this.loadStopWords();
            analyzer = new StandardAnalyzer();
            log.debug("Using StandardAnalyzer for indexing");
        } else {
            //try to create specified analyzer
            try {
                log.debug("About to load Analyzer [" + analyzerClassName + "] for indexing");
                analyzer = (Analyzer) Class.forName(analyzerClassName).newInstance();
            } catch (Exception e) {
                log.warn("Cannot load " + analyzerClassName + ". Loading StandardAnalyzer");
                analyzer = new StandardAnalyzer();
            }
        }
    }

    /**
     * This method is used for getting new IndexWriter. It can create new index
     * or add company to existing index. Creating new index will delete previous so it
     * should be used for rebuilding index.
     * @param create - true if new index should be created.
     *               - false for adding companies to existing index
     * @return IndexWriter object that is used for adding companies to index
     */
    static IndexWriter getIndexWriter(boolean create) throws SearchException {
        IndexWriter writer = null;

        //If create = false, we will create IndexWriter with false argument
        if (create == false) {
            try {
                writer = new IndexWriter(searchCompanyIndexDir, analyzer, false);
                writer.setUseCompoundFile(true);
                return writer;
            } catch (IOException e) {
                log.warn("Cannot open existed index. New index will be created.", e);
                //Ignore Exception. We will try to create index with true parameter
            }
        }
        // We are here in two cases: We wanted to create new index or because
        // index doesn't existed
        try {
            //This will create new index and delete existing
            writer = new IndexWriter(searchCompanyIndexDir, analyzer, true);
            writer.setUseCompoundFile(true);
            return writer;
        } catch (IOException e) {
            throw new SearchException("Error while creating index writer");
        }
    }

    /**
     * This method is used for adding single company to index
     * Note: this method doesnt close the writer
     * @param companyBean A company that should be indexed
     * @param writer IndexWriter that is used for storing
     * @throws SearchException
     */
    static void doIndexCompany(CompanyBean companyBean, IndexWriter writer) throws SearchException {
        //log.debug("WHAT COMPANY ?" + companyBean.getCompanyName());
        //Note that:: user can add a company without having the such fields
        //However, search engine trict this problem more seriously.
        if (companyBean == null) return;
        if ( (companyBean.getCompanyID() == 0)||
             (companyBean.getCompanyName() == null || companyBean.getCompanyName().equals("")) ||
             (companyBean.getCompanyAddress() == null) ||
             (companyBean.getCompanyCreationDate() == null) ||
             (companyBean.getCompanyModifiedDate() == null)) {
            return;
        }

        //Each company will be represented as a document
        Document companyDocument = new Document();
        //Document has following fields that could be queried on
        companyDocument.add(Field.Keyword(FIELD_COMPANY_ID, Integer.toString(companyBean.getCompanyID())));
        //document companyname and company address is not stored since we can retrieve them from database
        companyDocument.add(Field.UnStored(FIELD_COMPANY_NAME, companyBean.getCompanyName()));
        companyDocument.add(Field.UnStored(FIELD_COMPANY_ADDRESS, companyBean.getCompanyAddress()));
        //add date field
        companyDocument.add(Field.Keyword(FIELD_CREATION_DATE, DateField.dateToString(companyBean.getCompanyCreationDate())));//companyBean.getCompanyCreationDate())); // DateField.dateToString(companyBean.getCompanyCreationDate())));
        companyDocument.add(Field.Keyword(FIELD_MODIFIED_DATE, DateField.dateToString(companyBean.getCompanyModifiedDate()))); // DateField.dateToString(companyBean.getCompanyModifiedDate())));
        //now we have created document with fields so we can store it
        try {
            writer.addDocument(companyDocument);
        } catch (IOException e) {
            log.error("CompanyIndexer.doIndexCompany failed", e);
            throw new SearchException("Error writing new company to index");
        }
    }

    /**
     * Add single company to index
     * @param companyBean
     * @throws SearchException
     */
    static void addCompanyToIndex(CompanyBean companyBean) throws SearchException, IOException {
        IndexWriter writer = null;
        try {
            writer = getIndexWriter(false);
            if (writer == null) {
                log.warn("Cannot get the IndexWriter");
                return;
            }
            doIndexCompany(companyBean, writer);

            // now check if we should optimize index (each hour)
            long now = System.currentTimeMillis();
            long timeFromLastOptimize = now - lastOptimizeTime;
            if (timeFromLastOptimize > DateUtil.HOUR) {
                log.debug("writer.optimize() called in addCompanyToIndex");
                writer.optimize();
                lastOptimizeTime = now;
            }
        } catch (SearchException ex) {
            throw ex;
        } finally {
            try {
                if (writer != null) {
                    writer.close();
                }
            } catch (IOException e) {
            }
        }
    }

    /**
     * This method is used for deleting company from index.
     * @param companyID is id of the company that should be deleted
     * @throws SearchException
     */
    static void deleteCompanyFromIndex(int companyID) throws SearchException {
        IndexReader reader = null;
        try {
            reader = IndexReader.open(searchCompanyIndexDir);
            if (reader == null) {
                log.warn("Cannot get the IndexReader");
                return;
            }

            Term term = new Term(FIELD_COMPANY_ID, String.valueOf(companyID));
            int deletedCount = reader.delete(term);
            log.debug("deleteCompanyFromIndex: deleted companies = " + deletedCount);
        } catch (IOException e) {
            throw new SearchException("Error trying to delete company with companyID = " + companyID);
        } finally {
            try {
                if (reader != null) {
                    reader.close();
                }
            } catch (IOException e) {
            }
        }
    }

    public static IndexSearcher getSearcher() throws IOException {
        try {
            IndexSearcher searcher = new IndexSearcher(searchCompanyIndexDir);
            return searcher;
        } catch (IOException ex) {
            // we throw new IOException because the original exception
            // contain sensitive directory information
            log.error("Cannot access the lucene search index for query. Please check if you have configed mvnForumHome properly. You can also go to Admin Zone to rebuild the Lucene index files.", ex);
            //@todo : localize me
            throw new IOException("Cannot access the lucene search index. Please report this error to web site Administrator (check mvnForumHome or rebuild Lucene index).");
        }
    }

    public static int getNumDocs() {
        int numDocs = -1;
        IndexReader reader = null;
        try {
            reader = IndexReader.open(searchCompanyIndexDir);
            if (reader == null) {
                log.warn("Cannot get the IndexReader");
                return -1;
            }
            numDocs = reader.numDocs();
        } catch ( IOException ioe) {
            //ignore
        } finally {
            try {
                if (reader != null) reader.close();
            } catch (IOException e) {
                log.debug("Error closing Lucene IndexReader", e);
            }
        }
        return numDocs;
    }

}