package org.paneris.bibliomania;

 import java.util.Enumeration;

 import javax.servlet.http.HttpServletRequest;

 import org.melati.Melati;

 import org.melati.servlet.Form;

 import org.melati.poem.AccessToken;

 import org.melati.poem.Persistent;

 import org.melati.poem.PoemTask;

 import org.melati.poem.PoemThread;

 import org.melati.poem.UnexpectedExceptionPoemException;

 import org.melati.template.ServletTemplateContext;

 import org.paneris.bibliomania.fti.ContextSearchResults;

 import org.paneris.bibliomania.fti.HitText;

 import org.paneris.bibliomania.fti.IndexOther;

 import org.paneris.bibliomania.fti.Library;

 import org.paneris.bibliomania.fti.Score;

 import org.paneris.bibliomania.fti.ScoredHitTextsEnumeration;

 import org.paneris.bibliomania.fti.SearchResults;

 import org.webmacro.WebMacroException;

 import org.webmacro.servlet.HandlerException;

 import org.webmacro.servlet.WebContext;

 import com.sleepycat.db.DatabaseException;

 public class Search extends BibliomaniaServlet {

   private static final long serialVersionUID = 1L;

   protected String bibliomaniaHandle(Melati melati, WebContext context) throws WebMacroException {

     ServletTemplateContext tc = melati.getServletTemplateContext();

     String queryText = Form.getFieldNulled(tc, "queryText");

     String queryHeadwords = Form.getFieldNulled(tc, "queryHeadwords");  // No longer in form

     if (queryText == null && queryHeadwords == null)

       return bibliomaniaTemplate("search/Search.wm");

     context.put("queryText", queryText == null ? "" : queryText);

     context.put("queryHeadwords", queryHeadwords == null ? "" : queryHeadwords);

     int start = 0;

     String startString = context.getForm("start");

     if (startString != null) {

       try {

         start = Math.max(0, Integer.parseInt(startString));

       } catch (NumberFormatException e) {

         throw new HandlerException("`start' param must be a number");

       }

     }

     BibliomaniaDatabase bib = (BibliomaniaDatabase)PoemThread.database();

     if (!bib.openBerkelyDBs()) { 

       context.put("message", "Full text search has been temporarily switched off, sorry.");      

     } else  { 

       boolean infoSearch = "true".equals(context.getForm("info"));

       IndexOther fti = infoSearch ? bib.infoFTI() : bib.fti();

       Library lib = infoSearch ? bib.infoLibrary() : bib.getChapterTable();

       context.put("info", infoSearch ? Boolean.TRUE : null);

       SearchResults raw;

       try {

         raw = fti.querySearchResults(queryText, queryHeadwords);

         PoemThread.toTidy().add(raw);

       } catch (DatabaseException e) {

         throw new HandlerException(

           "Problem with Full Text index:" + e.toString());

       }

       ContextSearchResults results;

       results = new ContextSearchResults(lib, raw, fti);

       PoemThread.toTidy().add(results);

       String hitsPerTextString = context.getForm("hitsPerText");

       int hitsPerText;

       if (hitsPerTextString != null && !hitsPerTextString.trim().equals(""))

         try {

           hitsPerText = Math.max(0, Integer.parseInt(hitsPerTextString));

           if (hitsPerText == 0)

             hitsPerText =

               ((BibliomaniaDatabase)melati.getDatabase())

                 .getDefaultSearchHitsPerText();

         } catch (NumberFormatException e) {

           throw new HandlerException("`hitsPerText' param must be a number");

         } else

           hitsPerText =

           ((BibliomaniaDatabase)melati.getDatabase())

             .getDefaultSearchHitsPerText();

       long startTextID = 0;

       long limitTextID = Long.MAX_VALUE;

       boolean restrict = "true".equals(context.getForm("restrict"));

       if (restrict) {

         Persistent object = melati.getObject();

         if (object != null && object instanceof Unit) {

           startTextID = ((Unit)object).ftiTextID_start();

           limitTextID = ((Unit)object).ftiTextID_limit();

        }

       }

       context.put("restrict", restrict ? "true" : "false");

       Score.Hit[] order;

       try {

         order = Score.scoredHits(raw, startTextID, limitTextID, 50 /* FIXME */

         );

       } catch (DatabaseException e) {

         throw new HandlerException(

           "Problem with Full Text index:" + e.toString());

       }

       ScoredHitTextsEnumeration hits =

         new ScoredHitTextsEnumeration(

           results,

           order,

           start,

           bib.getSearchHitsPerPage(),

           hitsPerText);

       context.put("hitTexts", hits);

       context.put("count", order.length);

       context.put("hitsPerText", new Integer(hitsPerText));

       context.put("start", new Integer(hits.getPageStart()));

       context.put("end", new Integer(hits.getPageEnd()));

       HttpServletRequest req = context.getRequest();

       Integer prevStart = hits.getPrevPageStart();

       if (prevStart != null)

         context.put(

           "prevPageURI",

           req.getRequestURI()

             + "?"

             + Form.sameQueryWith(

               req.getQueryString(),

               "start",

               prevStart.toString()));

       Integer nextStart = hits.getNextPageStart();

       if (nextStart != null)

         context.put(

           "nextPageURI",

           req.getRequestURI()

             + "?"

             + Form.sameQueryWith(

               req.getQueryString(),

               "start",

               nextStart.toString()));

     }

     return bibliomaniaTemplate("search/Results.wm");

   }

   public static void main(final String[] args) throws Exception {

     IndexOther.debug = true;

     final BibliomaniaDatabase bib = new BibliomaniaDatabase(false);

     bib.connect("bibliomania",

       "org.melati.poem.dbms.Postgresql",

       "jdbc:postgresql:bibliomania",

       "postgres",

       "*",

       8);

     bib.inSession(AccessToken.root, new PoemTask() {

       public void run() {

         try {

           SearchResults raw = bib.fti().querySearchResults(args[0]);

           int hitsPerText = 10;

           long startTextID;

           if (args.length < 3)

             startTextID = 0L;

           else if (args[1].equals("tid"))

             startTextID = Long.parseLong(args[2]);

           else

             startTextID =

               ((Unit)bib

                 .getTable(args[1])

                 .getObject(Integer.parseInt(args[2])))

                 .ftiTextID_start();

           long limitTextID;

           if (args.length < 5)

             limitTextID = Long.MAX_VALUE;

           else if (args[3].equals("tid"))

             limitTextID = Long.parseLong(args[4]);

           else

             limitTextID =

               ((Unit)bib

                 .getTable(args[3])

                 .getObject(Integer.parseInt(args[4])))

                 .ftiTextID_start();

           System.err.println("[ " + startTextID + ", " + limitTextID + ")");

           Score.Hit[] order =

             Score.scoredHits(raw, startTextID, limitTextID, 50);

           ContextSearchResults results =

             new ContextSearchResults(bib.getChapterTable(), raw, bib.fti());

           Enumeration hits =

             new ScoredHitTextsEnumeration(

               results,

               order,

               0,

               bib.getSearchHitsPerPage(),

               hitsPerText);

           while (hits.hasMoreElements())

              ((HitText)hits.nextElement()).dump();

         } catch (Exception e) {

           throw new UnexpectedExceptionPoemException(e);

         }

       }

     });

   }

 }