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);
         }
       }
     });
   }
 }