package com.pdflib.tet.lucene;

/**
 * (C) PDFlib GmbH 2015-2019 www.pdflib.com
 *
 * This code is based on the Lucene Java command-line demo, which is part of the
 * Lucene Java distribution available at http://lucene.apache.org/java. This
 * code has been tested with Lucene Java 5.2.1.
 * 
 * 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.
 *
 */

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.nio.file.Paths;
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.DirectoryReader;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexableField;
import org.apache.lucene.queryparser.classic.QueryParser;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.FSDirectory;

/** Simple command-line based search demo. */
public class SearchFiles
{
    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
         */
        PrintStream 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] [-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;
        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 ("-paging".equals(args[i])) {
                hitsPerPage = Integer.parseInt(args[i + 1]);
                if (hitsPerPage <= 0) {
                    System.err
                            .println("There must be at least 1 hit per page.");
                    System.exit(1);
                }
                i++;
            }
        }

        IndexReader reader = DirectoryReader
                .open(FSDirectory.open(Paths.get(index)));
        IndexSearcher 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, 100);
                }
                Date end = new Date();
                out.println("Time: " + (end.getTime() - start.getTime())
                        + "ms");
            }

            doPagingSearch(in, out, searcher, query, hitsPerPage, raw,
                        queries == null);
        }
        reader.close();
    }

    /**
     * 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, PrintStream out,
            IndexSearcher searcher, Query query, int hitsPerPage,
            boolean raw, boolean interactive)
            throws IOException
    {

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

        int numTotalHits = (int) results.totalHits.value;
        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;
                }

                hits = searcher.search(query, numTotalHits).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)
                {
                    // Print some information about the PDF document
                    out.println((i + 1) + ". " + path);
                    String title = doc.get("title");
                    if (title != null)
                    {
                        out.println("   Title: " + title);
                    }
                    
                    String subject = doc.get("summary");
                    if (subject != null)
                    {
                        out.println("   Subject: " + subject);
                    }
                    
                    IndexableField[] fontFields = doc.getFields("font");
                    for (IndexableField font: fontFields) {
                            out.println("   Font : " + font.stringValue());
                    }
                }
                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);
            }
        }
    }
}
