package com.pdflib.tet.lucene;

/**
 * (C) PDFlib GmbH 2008 www.pdflib.com
 *
 * This code is based on the Lucene Java "Basic Demo", which is part of the
 * Lucene Java distribution available at http://lucene.apache.org/java. This
 * code has been tested with Lucene Java 2.4.0.
 * 
 * The original code carried the following copyright notice:
 * 
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * 
 * @version $Id: SearchFiles.java,v 1.1 2008/11/11 20:37:48 tm Exp $
 */

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.util.Date;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.index.FilterIndexReader;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.search.HitCollector;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.Searcher;
import org.apache.lucene.search.TopDocCollector;

/** Simple command-line based search demo. */
public class SearchFiles
{
    /**
     * For printing to System.out in UTF-8 encoding.
     */
    private static PrintStream out;
    
    /**
     * Use the norms from one field for all fields. Norms are read into memory,
     * using a byte of memory per document per searched field. This can cause
     * search of large collections with a large number of fields to run out of
     * memory. If all of the fields contain only a single token, then the norms
     * are all identical, then single norm vector may be shared.
     */
    private static class OneNormsReader extends FilterIndexReader
    {
        private String field;

        public OneNormsReader(IndexReader in, String field)
        {
            super(in);
            this.field = field;
        }

        public byte[] norms(String field) throws IOException
        {
            return in.norms(this.field);
        }
    }

    private SearchFiles()
    {
    }

    /** Simple command-line based search demo. */
    public static void main(String[] args) throws Exception
    {
        /*
         * As a modification to the standard Lucene SearchFiles class, we
         * print all output encoded as UTF-8. This makes it possible in certain
         * environments, for example Mac OS X, that a user can paste CJK characters
         * into the terminal window, and also query results will display the
         * CJK characters in a hit correctly
         */
        out = new PrintStream(System.out, true, "UTF-8");
        
        String usage = "Usage:\tjava org.apache.lucene.demo.SearchFiles [-index dir] [-field f] [-repeat n] [-queries file] [-raw] [-norms field] [-paging hitsPerPage]";
        usage += "\n\tSpecify 'false' for hitsPerPage to use streaming instead of paging search.";
        
        if (args.length > 0
                && ("-h".equals(args[0]) || "-help".equals(args[0])))
        {
            out.println(usage);
            System.exit(0);
        }

        String index = "index";
        String field = "contents";
        String queries = null;
        int repeat = 0;
        boolean raw = false;
        String normsField = null;
        boolean paging = true;
        int hitsPerPage = 10;

        for (int i = 0; i < args.length; i++)
        {
            if ("-index".equals(args[i]))
            {
                index = args[i + 1];
                i++;
            }
            else if ("-field".equals(args[i]))
            {
                field = args[i + 1];
                i++;
            }
            else if ("-queries".equals(args[i]))
            {
                queries = args[i + 1];
                i++;
            }
            else if ("-repeat".equals(args[i]))
            {
                repeat = Integer.parseInt(args[i + 1]);
                i++;
            }
            else if ("-raw".equals(args[i]))
            {
                raw = true;
            }
            else if ("-norms".equals(args[i]))
            {
                normsField = args[i + 1];
                i++;
            }
            else if ("-paging".equals(args[i]))
            {
                if (args[i + 1].equals("false"))
                {
                    paging = false;
                }
                else
                {
                    hitsPerPage = Integer.parseInt(args[i + 1]);
                    if (hitsPerPage == 0)
                    {
                        paging = false;
                    }
                }
                i++;
            }
        }

        IndexReader reader = IndexReader.open(index);

        if (normsField != null)
            reader = new OneNormsReader(reader, normsField);

        Searcher searcher = new IndexSearcher(reader);
        Analyzer analyzer = new StandardAnalyzer();

        BufferedReader in = null;
        if (queries != null)
        {
            in = new BufferedReader(new FileReader(queries));
        }
        else
        {
            in = new BufferedReader(new InputStreamReader(System.in, "UTF-8"));
        }
        QueryParser parser = new QueryParser(field, analyzer);
        while (true)
        {
            if (queries == null) // prompt the user
                out.println("Enter query: ");

            String line = in.readLine();

            if (line == null || line.length() == -1)
                break;

            line = line.trim();
            if (line.length() == 0)
                break;

            Query query = parser.parse(line);
            out.println("Searching for: " + query.toString(field));

            if (repeat > 0)
            { // repeat & time as benchmark
                Date start = new Date();
                for (int i = 0; i < repeat; i++)
                {
                    searcher.search(query, null, 100);
                }
                Date end = new Date();
                out.println("Time: " + (end.getTime() - start.getTime())
                        + "ms");
            }

            if (paging)
            {
                doPagingSearch(in, searcher, query, hitsPerPage, raw,
                        queries == null);
            }
            else
            {
                doStreamingSearch(searcher, query);
            }
        }
        reader.close();
    }

    /**
     * This method uses a custom HitCollector implementation which simply prints
     * out the docId and score of every matching document.
     * 
     * This simulates the streaming search use case, where all hits are supposed
     * to be processed, regardless of their relevance.
     */
    public static void doStreamingSearch(final Searcher searcher, Query query)
            throws IOException
    {
        HitCollector streamingHitCollector = new HitCollector()
        {

            // simply print docId and score of every matching document
            public void collect(int doc, float score)
            {
                out.println("doc=" + doc + " score=" + score);
            }

        };

        searcher.search(query, streamingHitCollector);
    }

    /**
     * This demonstrates a typical paging search scenario, where the search
     * engine presents pages of size n to the user. The user can then go to the
     * next page if interested in the next hits.
     * 
     * When the query is executed for the first time, then only enough results
     * are collected to fill 5 result pages. If the user wants to page beyond
     * this limit, then the query is executed another time and all hits are
     * collected.
     * 
     */
    public static void doPagingSearch(BufferedReader in, Searcher searcher,
            Query query, int hitsPerPage, boolean raw, boolean interactive)
            throws IOException
    {

        // Collect enough docs to show 5 pages
        TopDocCollector collector = new TopDocCollector(5 * hitsPerPage);
        searcher.search(query, collector);
        ScoreDoc[] hits = collector.topDocs().scoreDocs;

        int numTotalHits = collector.getTotalHits();
        out.println(numTotalHits + " total matching documents");

        int start = 0;
        int end = Math.min(numTotalHits, hitsPerPage);

        while (true)
        {
            if (end > hits.length)
            {
                out
                        .println("Only results 1 - " + hits.length + " of "
                                + numTotalHits
                                + " total matching documents collected.");
                out.println("Collect more (y/n) ?");
                String line = in.readLine();
                if (line.length() == 0 || line.charAt(0) == 'n')
                {
                    break;
                }

                collector = new TopDocCollector(numTotalHits);
                searcher.search(query, collector);
                hits = collector.topDocs().scoreDocs;
            }

            end = Math.min(hits.length, start + hitsPerPage);

            for (int i = start; i < end; i++)
            {
                if (raw)
                { // output raw format
                    out.println("doc=" + hits[i].doc + " score="
                            + hits[i].score);
                    continue;
                }

                Document doc = searcher.doc(hits[i].doc);
                String path = doc.get("path");
                if (path != null)
                {
                    out.println((i + 1) + ". " + path);
                    String title = doc.get("title");
                    if (title != null)
                    {
                        out.println("   Title: " + doc.get("title"));
                    }
                }
                else
                {
                    out.println((i + 1) + ". "
                            + "No path for this document");
                }

            }

            if (!interactive)
            {
                break;
            }

            if (numTotalHits >= end)
            {
                boolean quit = false;
                while (true)
                {
                    out.print("Press ");
                    if (start - hitsPerPage >= 0)
                    {
                        out.print("(p)revious page, ");
                    }
                    if (start + hitsPerPage < numTotalHits)
                    {
                        out.print("(n)ext page, ");
                    }
                    out
                            .println("(q)uit or enter number to jump to a page.");

                    String line = in.readLine();
                    if (line.length() == 0 || line.charAt(0) == 'q')
                    {
                        quit = true;
                        break;
                    }
                    if (line.charAt(0) == 'p')
                    {
                        start = Math.max(0, start - hitsPerPage);
                        break;
                    }
                    else if (line.charAt(0) == 'n')
                    {
                        if (start + hitsPerPage < numTotalHits)
                        {
                            start += hitsPerPage;
                        }
                        break;
                    }
                    else
                    {
                        int page = Integer.parseInt(line);
                        if ((page - 1) * hitsPerPage < numTotalHits)
                        {
                            start = (page - 1) * hitsPerPage;
                            break;
                        }
                        else
                        {
                            out.println("No such page");
                        }
                    }
                }
                if (quit)
                    break;
                end = Math.min(numTotalHits, start + hitsPerPage);
            }

        }

    }
}
