package org.paneris.bibliomania.metasearch;
   
   import java.util.Enumeration;
   import java.util.NoSuchElementException;
   import java.util.Vector;
   
   import org.melati.poem.transaction.ToTidyList;
   import org.paneris.bibliomania.BookStocking;
   import org.paneris.bibliomania.Bookshop;
  
  public class Metasearch implements ToTidyList.Closeable {
  
    private Bookshop[] shops;
    private String title;
    private String author;
    private ToTidyList toTidy;
    private SearchThread[] threads;
    private Vector results = new Vector();
    private int runningThreads = 0;
  
    private class SearchThread extends Thread {
      private Bookshop shop;
  
      public SearchThread(Bookshop shop) {
        this.shop = shop;
      }
  
      public void run() {
        try {
          Enumeration books =
            shop.backend.booksMatching(shop, title, author, "", "", toTidy);
          while (books.hasMoreElements()) {
            BookStocking stocking = (BookStocking)books.nextElement();
            shop.backend.resolve(stocking);
            synchronized (results) {
              results.addElement(stocking);
              results.notifyAll();
            }
          }
        } catch (Exception e) {
          System.err.println("Metasearch.SearchThread: " + e);
        } finally {
          synchronized (results) {
            --runningThreads;
            results.notifyAll();
            if (runningThreads <= 0) {
              synchronized (Metasearch.this) {
                Metasearch.this.notifyAll();
              }
            }
          }
        }
      }
  
      public void close() {
        try {
          stop();
        } catch (Exception e) {
        }
      }
    }
  
    private class HitsEnumeration implements Enumeration {
  
      private int nextResultIndex = 0;
      private Object next = null;
  
      public boolean hasMoreElements() {
        try {
          synchronized (results) {
            if (next != null)
              return true;
  
            while (nextResultIndex >= results.size()) {
              if (runningThreads <= 0)
                return false;
              results.wait();
            }
  
            next = results.elementAt(nextResultIndex++);
            return true;
          }
        } catch (InterruptedException e) {
          return false;
        }
      }
  
      public Object nextElement() {
        synchronized (results) {
          if (hasMoreElements()) {
            Object it = next;
            next = null;
            return it;
          } else
            throw new NoSuchElementException("No more search hits");
        }
      }
    }
  
   public Metasearch(
     Bookshop[] shopsP,
     String title,
     String author,
     ToTidyList toTidy) {
     this.shops = shopsP;
     this.title = title;
     this.author = author;
     this.toTidy = toTidy;
 
     threads = new SearchThread[shops.length];
     if (toTidy != null)
       toTidy.add(this);
 
     for (int s = 0; s < shops.length; ++s) {
       (threads[s] = new SearchThread(shops[s])).start();
       synchronized (results) {
         ++runningThreads;
       }
     }
   }
 
   public Enumeration currentAndFutureResults() {
     return new HitsEnumeration();
   }
 
   public Vector currentResults() {
     return results;
   }
 
   public boolean running() {
     return runningThreads > 0;
   }
 
   public void close() {
     try {
       for (int i = 0; i < threads.length; ++i)
         try {
           threads[i].stop();
         } catch (Exception e) {
         }
     } finally {
       synchronized (this) {
         runningThreads = 0;
         notifyAll();
       }
     }
   }
 
   protected void finalize() throws Throwable {
     close();
   }
 }