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

             }

           }

         });

   }

 }