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

   }

 }