package org.paneris.bibliomania.loadtest;
   
   import java.io.BufferedReader;
   import java.io.FileInputStream;
   import java.io.FileReader;
   import java.io.InputStream;
   import java.io.ObjectInputStream;
   import java.net.URL;
   import java.util.Enumeration;
  import java.util.Random;
  import java.util.Vector;
  
  import org.melati.util.UnexpectedExceptionException;
  
  class HitStats {
    public long totalToOpen, totalToFinish;
    public int successes;
    public int failures;
    // public int errors;
  
    public void notifyTransaction(long started, long opened, long finished
                                  // , boolean error
                                  ) {
      totalToOpen += opened - started;
      totalToFinish += finished - started;
      // if (error) ++errors else
      ++successes;
    }
  
    public void notifyFailure() {
      ++failures;
    }
  
    public long meanToOpen() {
      return successes == 0 ? 0 : totalToOpen / successes;
    }
  
    public long meanToFinish() {
      return successes == 0 ? 0 : totalToFinish / successes;
    }
  }
  
  class ExponentialDistribution {
    private double minusMean;
  
    public ExponentialDistribution(double mean) {
      minusMean = -mean;
    }
  
    public double sample() {
      for (;;) {
        float x = LoadTest.random.nextFloat();
        if (x != 0.)
          return minusMean * Math.log(x);
      }
    }
  }
  
  class BitBucket extends Thread {
    private String url;
    private HitStats stats;
  
    public BitBucket(String url, HitStats stats) {
      this.url = url;
      this.stats = stats;
    }
  
    private static final byte[] b = new byte[4096];
  
    public void run() {
      System.err.println(url);
      try {
        long started = System.currentTimeMillis();
        InputStream i = new URL(url).openStream();
        long opened = System.currentTimeMillis();
        while (i.read(b) != -1);
        long finished = System.currentTimeMillis();
  
        stats.notifyTransaction(started, opened, finished);
      }
      catch (Exception e) {
        //System.err.println(e);
        stats.notifyFailure();
      }
    }
  }
  
  abstract class Level {
    abstract String urlFromSection(BookDesc book);
    String url(BookDesc book) {
      return book.sectiongroup + "/" + urlFromSection(book);
    }
  }
  
  class SectionLevel extends Level {
    String urlFromSection(BookDesc book) {
      return "" + book.section;
    }
  
   public String toString() {
     return "sec";
   }
 }
 
 class AuthorLevel extends Level {
   String urlFromSection(BookDesc book) {
     return book.section + "/" + book.author;
   }
 
   public String toString() {
     return "aut";
   }
 }
 
 class BookLevel extends Level {
   String urlFromSection(BookDesc book) {
     return book.section + "/" + book.author + "/" + book.book;
   }
 
   public String toString() {
     return "bok";
   }
 }
 
 class ChapterLevel extends Level {
   String urlFromSection(BookDesc book) {
     ChapterDesc c =
         book.chapters[LoadTest.random.nextInt(book.chapters.length)];
     return book.section + "/" + book.author + "/" + book.book + "/" +
            c.chapter + "/" + (LoadTest.random.nextInt(c.pages) + 1) + ".html";
   }
 
   public String toString() {
     return "cha";
   }
 }
 
 abstract class Urler {
   abstract String urlPath(Level level, BookDesc book);
 }
 
 class ReadUrler extends Urler {
   String urlPath(Level level, BookDesc book) {
     return level.url(book);
   }
 
   public String toString() {
     return "read";
   }
 }
 
 class SearchUrler extends Urler {
 
   static String[] words;
 
   static {
     try {
       Vector w = new Vector();
       BufferedReader r = new BufferedReader(new FileReader("/usr/share/dict/words"));
       for (;;) {
         String s = r.readLine();
         if (s == null)
           break;
         w.addElement(s);
       }
       words = new String[w.size()];
       w.copyInto(words);
     }
     catch (Exception e) {
       e.printStackTrace();
       System.exit(1);
     }
   }
 
   static String randomWord() {
     return words[LoadTest.random.nextInt(words.length)];
   }
 
   int searchgroup;
   int numwords;
 
   SearchUrler(int searchgroup, int numwords) {
     this.searchgroup = searchgroup;
     this.numwords = numwords;
   }
 
   String urlPath(Level level, BookDesc book) {
     StringBuffer qt = new StringBuffer();
 
     qt.append(randomWord());
 
     for (int i = 1; i < numwords; ++i) {
       qt.append("+");
       qt.append(randomWord());
     }
 
     return
         "b/org.paneris.bibliomania.Search/" + searchgroup + "/" +
         level.urlFromSection(book) + "?" + "queryText=" + qt;
   }
 
   public String toString() {
     return "search(" + numwords + ")";
   }
 }
 
 class ReqType {
   HitStats stats = new HitStats();
   Urler urler;
   Level level;
 
   ReqType(Urler urler, Level level) {
     this.urler = urler;
     this.level = level;
   }
 
   void go(BookDesc book) {
     new BitBucket(LoadTest.urlPrefix + urler.urlPath(level, book), stats).
         start();
   }
 
   public String toString() {
     return urler + "/" + level;
   }
 }
 
 public class LoadTest {
 
   static Random random = new Random();
   static String urlPrefix;
 
   private long runtimeMillis;
   private boolean keepGoing;
   private ExponentialDistribution wait;
   private DiscreteDistribution types = new DiscreteDistribution();
   private int searchsectiongroup;
 
   public LoadTest(long runtimeMillis, int hitsPerSec, int kSearch) {
     this.runtimeMillis = runtimeMillis;
     wait = new ExponentialDistribution(1000 / hitsPerSec);
 
     types = new DiscreteDistribution();
 
     Urler
         read = new ReadUrler(),
         search1 = new SearchUrler(searchsectiongroup, 1),
         search2 = new SearchUrler(searchsectiongroup, 2);
         //search3 = new SearchUrler(searchsectiongroup, 3);
 
     Level
         sec = new SectionLevel(),
         aut = new AuthorLevel(),
         bok = new BookLevel(),
         cha = new ChapterLevel();
     
     types.add(new ReqType(read, sec), 6);
     types.add(new ReqType(read, aut), 12);
     types.add(new ReqType(read, bok), 18);
     types.add(new ReqType(read, cha), 37);
     /*
     types.add(new ReqType(search1, sec), 2 * kSearch);
     types.add(new ReqType(search1, aut), 2 * kSearch);
     types.add(new ReqType(search1, bok), 2 * kSearch);
     types.add(new ReqType(search2, sec), 1 * kSearch);
     types.add(new ReqType(search2, aut), 1 * kSearch);
     types.add(new ReqType(search2, bok), 1 * kSearch);
     */
   }
 
   private class Stopper extends Thread {
     public void run() {
       try {
         Thread.sleep(runtimeMillis);
       }
       catch (Exception e) {
         throw new UnexpectedExceptionException(e);
       }
 
       keepGoing = false;
     }
   }
 
   public static String pad(String it, int w) {
     StringBuffer s = new StringBuffer(w);
     while (s.length() + it.length() < w)
       s.append(' ');
     s.append(it);
     return s.toString();
   }
 
   public static String pad(long l, int w) {
     return pad("" + l, w);
   }
 
   public void run() throws Exception {
     keepGoing = true;
     new Stopper().start();
 
     while (keepGoing) {
       Thread.sleep((long)wait.sample());
       ((ReqType)types.sample()).go((BookDesc)extractTree.books.sample());
     }
 
     System.err.println("stopping");
     Thread.sleep(5);
 
     System.out.println();
     System.out.println("        win open end fail");
     for (Enumeration h = types.elements(); h.hasMoreElements();) {
       ReqType hit = (ReqType)h.nextElement();
       System.out.print(hit.toString());
       System.out.println(
           pad(hit.stats.successes, 9) + " " +
           pad(hit.stats.meanToOpen(), 5) + " " +
           pad(hit.stats.meanToFinish(), 5) + " " +
           pad(hit.stats.failures, 5) + " ");
     }
   }
 
   static ExtractTree extractTree;
 
   public static void main(String[] args) throws Exception {
     ObjectInputStream i =
         new ObjectInputStream(new FileInputStream("books.ser"));
 
     extractTree = (ExtractTree)i.readObject();
 
     i.close();
 
     /*
     urlPrefix = "http://" + args[0] + "/";
     new LoadTest(Integer.parseInt(args[1]) * 1000L,
         Integer.parseInt(args[2]),
         Integer.parseInt(args[3])).run();
         */
     urlPrefix = "http://bibliomania.com/";
     new LoadTest(new Integer(40) * 1000L,
         new Integer(200),
         new Integer(32)).run();
   }
 }