package org.paneris.bibliomania;
   
   import java.io.File;
   import java.io.IOException;
   import java.sql.Timestamp;
   import java.util.Enumeration;
   import java.util.Hashtable;
   import java.util.Vector;
   
  import org.melati.poem.AccessToken;
  import org.melati.poem.PoemTask;
  import org.melati.poem.PoemThread;
  import org.melati.poem.UnexpectedExceptionPoemException;
  import org.melati.poem.util.ArrayEnumeration;
  import org.melati.poem.util.Order;
  import org.melati.poem.util.SortUtils;
  import org.melati.poem.transaction.ToTidyList;
  import org.melati.util.UnexpectedExceptionException;
  import org.paneris.bibliomania.generated.StockingsSearchBase;
  import org.paneris.bibliomania.metasearch.Metasearch;
  import org.webmacro.WebMacroException;
  
  public class StockingsSearch extends StockingsSearchBase {
  
    public BibliomaniaDatabase getBibliomaniaDatabase () {
        return (BibliomaniaDatabase)getDatabase();
    }
  
    public StockingsSearch() {}
  
    private long timeout;
    private SearchThread searchThread;
  
    private static class DisplayOrder implements Order {
  
      private static int iom(Integer i) {
        return i == null ? Integer.MAX_VALUE : i.intValue();
      }
  
      public boolean lessOrEqual(Object a, Object b) {
        BookStocking sa = (BookStocking)a;
        BookStocking sb = (BookStocking)b;
  
        int fca = iom(sa.getFormatcode_unsafe());
        int fcb = iom(sb.getFormatcode_unsafe());
  
        if (fca < fcb) return true;
        else if (fca > fcb) return false;
  
        int pna = iom(sa.getPricenumber_unsafe());
        int pnb = iom(sb.getPricenumber_unsafe());
  
        return pna <= pnb;
      }
  
      public static final Order it = new DisplayOrder();
    }
  
    public class CollatingResults {
  
      private Object[] sorted;
  
      public CollatingResults(Vector baseResults) {
        sorted = SortUtils.sorted(DisplayOrder.it, baseResults);
      }
  
      public Enumeration startingAtRow(int row) {
        return new Buy.CollatedHitsEnumeration(
                   new ArrayEnumeration(sorted),
                   getBibliomaniaDatabase().bookshops().length, row);
      }
    }
  
    private class SearchThread extends Thread {
  
      Metasearch search;
      ToTidyList toTidy = new ToTidyList();
  
      public SearchThread() {
        final BibliomaniaDatabase database = getBibliomaniaDatabase();
        database.notifyBookshopSearchStart();
        search = new Metasearch(database.bookshops(),
                                getTitleterm_unsafe(),
                                getAuthorterm_unsafe(),
                                toTidy);
        start();
      }
  
      public void run() {
        final BibliomaniaDatabase database = getBibliomaniaDatabase();
  
        try {
          synchronized (search) {
            try {
              search.wait(timeout);
            }
            catch (InterruptedException e) {
              search.close();
              return;
           }
         }
 
         if (search.running())
           search.close();
 
         toTidy.close();
 
         database.inSession(
             AccessToken.root,
             new PoemTask() {
               public void run() {
                 try {
                   File cache = cachedResultsFile();
 
                   File dir = cache.getParentFile();
                   if (!dir.exists())
                     dir.mkdirs();
 
                   Hashtable extras = new Hashtable();
                   extras.put("results",
                              new CollatingResults(search.currentResults()));
 
                   getBibliomaniaDatabase().interpolateTemplateToFile(
                       "metasearch/CachedResults.wm", cache, null, extras);
                 }
                 catch (WebMacroException e) {
                   throw new UnexpectedExceptionException(e);
                 }
                 catch (IOException e) {
                   throw new UnexpectedExceptionException(e);
                 }
                 finally {
                   setLastperformed(new Timestamp(System.currentTimeMillis()));
                   PoemThread.commit();
                 }
               }
             });
       }
       catch (Exception e) {
         System.err.println("Exception in StockingsSearch for `" +
                            getAuthorterm_unsafe() + "'/`" +
                            getTitleterm_unsafe() + "'");
         e.printStackTrace();
       }
       finally {
         database.notifyBookshopSearchStop();
         synchronized (StockingsSearch.this) {
           searchThread = null;
         }
       }
     }
   }
 
   private Metasearch search() {
     SearchThread running = searchThread;
 
     if (running == null) {
       synchronized (this) {
         if (searchThread == null) {
           timeout =
               getBibliomaniaDatabase().getBibBookBookshopSearchTimeoutMillis();
           searchThread = new SearchThread();
         }
         running = searchThread;
       }
     }
 
     return running.search;
   }
 
   public void runNewSearch() {
     search();
   }
 
   public Enumeration newSearchResults() {
     return search().currentAndFutureResults();
   }
 
   private String cachedResultsFileLocation() {
     StringBuffer it = new StringBuffer();
     it.append(getBibliomaniaDatabase().getBookStockingsCacheDir());
 
     String t = troid().toString();
 
     if (t.length() % 2 == 1)
       t = '0' + t;
 
     for (int i = 0; i < t.length(); i += 2) {
       it.append('/');
       it.append(t.substring(i, i + 2));
     }
 
     it.append(".html");
 
     return it.toString();
   }
 
   private File cachedResultsFile() {
     return new File(cachedResultsFileLocation());
   }
 
   public boolean upToDate() {
     Timestamp last = getLastperformed();
     return last != null &&
            System.currentTimeMillis() - last.getTime() <
                getBibliomaniaDatabase().getBookStockingsCheckIntervalMillis();
   }
 
   public String cachedResultsPath() {
     if (!upToDate())
       return null;
     else {
       File it = cachedResultsFile();
       return it.exists() ? it.toString() : null;
     }
   }
 
   public void delete_unsafe() {
     super.delete_unsafe();
     cachedResultsFile().delete();
   }
 
   public static void main(final String[] args) {
     final BibliomaniaDatabase bib = new BibliomaniaDatabase(false, true);
     bib.connect("bibliomania","org.melati.poem.dbms.Postgresql",
                 "jdbc:postgresql:bibliomania", "postgres", "*",8);
 
     bib.setLogSQL(true);
 
     bib.inSession(
         AccessToken.root,
         new PoemTask() {
           public void run() {
             try {
               StockingsSearch s =
                   bib.getStockingsSearchTable().searchFor(args[0], args[1]);
               String res = s.cachedResultsPath();
               if (res != null)
                 System.out.println("-> " + res);
               else {
                 System.err.println("searching ...........");
                 for (Enumeration r = s.newSearchResults();
                      r.hasMoreElements();) {
                   BookStocking st = (BookStocking)r.nextElement();
                   System.out.println(st.getPublisher_unsafe() + " " +
                                      st.getShop_unsafe() + " " +
                                      st.getPrice_unsafe());
                 }
                 System.err.println("......... done searching");
               }
             }
             catch (Exception e) {
               throw new UnexpectedExceptionPoemException(e);
             }
           }
         });
   }
 }