/*
    * Copyright (c) 1998-2002 The Jgroup Team.
    *
    * This program is free software; you can redistribute it and/or modify
    * it under the terms of the GNU Lesser General Public License version 2 as
    * published by the Free Software Foundation.
    *
    * This program is distributed in the hope that it will be useful,
    * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public License
   * along with this program; if not, write to the Free Software
   * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
   *
   */
  
  package jgroup.test.performance.upgrade;
  
  import java.rmi.RemoteException;
  
  import jgroup.core.registry.DependableRegistry;
  import jgroup.core.registry.RegistryFactory;
  import jgroup.test.performance.SpeedTest;
  
  import org.apache.log4j.Logger;
  
  
  
  /**
   *  This class is used to generate client requests with a given rate. 
   *  The traffic is generated by repeated invocations sent to a given
   *  test server. Basic statistics is computed based on the response time 
   *  measurements taken during the process generation, including average,
   *  min and max times. 
   *
   *  @author Marcin Solarski
   *  @since Jgroup 2.1
   */
  class UpgradeClientTest
  {
  
    ////////////////////////////////////////////////////////////////////////////////////////////
    // Constants
    ////////////////////////////////////////////////////////////////////////////////////////////
  
    /** Max number of */
    private static final int CALIBRATE_NUM_CALLS = 10;
    private static final int BUFFER_SIZE = 1000;
  
    /** number of mili seconds in a second */ 
    private static final long  TIME_UNIT = 1000;  
  
    private SpeedTest test;
    private boolean calibrated = false;
    private DependableRegistry reg  = null;
    private float avRespTime = 0;
    private int method = 0;
  
     /** Obtain logger for this class */
    private static Logger log = Logger.getLogger(UpgradeClientTest.class);
  
    /**
     * default constuctor for the test. It resolves the name of the
     * given server.
     * Do not use thie constuctor for parrallel tests from one VMID.
     * JGroup does not properly handles invocation generation for
     * tests created that way.
     */
  
    public UpgradeClientTest(String name) throws Exception {
       prepareTest(name);
    }
  
  
    /**
     * constructor to be used for multi-threaded test clients
     */
    public UpgradeClientTest(SpeedTest t) {
      test = t;
    }
  
  
  
    private void prepareTest(String name) throws Exception {
          reg = RegistryFactory.getRegistry();
          test = (SpeedTest) reg.lookup(name);
    }
  
    /**
     * sends requests to the server with a given rate for the given time period. 
     * @param reqPerSec request rate (per second)
     * @param call_no  that requests will be sent to the server
     * @return a 3-element array of long with average, minimum and maximum times
     */
    public float generate_traffic(int reqPerSec, int call_no)
    {
      float time=0;
     if( ! calibrated ) return 0;
     long pauseTime = (long)( TIME_UNIT - reqPerSec * avRespTime) / reqPerSec;
     
     if (log.isDebugEnabled()) {
       log.debug("Planned experiment time " + call_no*reqPerSec );
       log.debug("Numer of calls " + call_no );
       log.debug("Pause time for the given user traffic throughput (" + reqPerSec +") is equals to " + pauseTime);
     }
 
     if( pauseTime < 0)  pauseTime = 0;
 
      if(method == 1) {
 	time = test_method1(call_no, pauseTime);
     } else if(method == 2) {
 	time = test_method2(call_no, pauseTime);
     } else if(method == 3) {
 	time = test_method3(call_no, pauseTime, BUFFER_SIZE);
     } else {
 	time = test_method4(call_no, pauseTime, BUFFER_SIZE);
     }
 
     log.debug("Average response time " + time );
     return time;
   
   }
 
   /**
    * calibrates the tests. Before a traffic can be generated, the test 
    * has to be calibratedi with respect to the given testing method.
    * @param method is a test method (1-4)
    */
     public float calibrate(int method) {
 	    return calibrate(method, CALIBRATE_NUM_CALLS);
     }
 
     
     public float calibrate(int method, int calibReqCallNo) {
       this.method= method;
       avRespTime = computeAverageResponseTime(method, calibReqCallNo);
       calibrated = true;
       log.info("Average response time during calibration = " + avRespTime);
       return avRespTime;
     }
 
    /**
     * compute an average response time for a given test method.
     * This time is computed by sending a number of test calls to the 
     * server, measuring the total time it took to process these calls
     * and dividing by the number of calls sent.
     * @param method is a test metho (1-4)
     */
     protected float computeAverageResponseTime(int method, int calibReqCallNo){
     float  time = 0;
 
     if (log.isDebugEnabled()) log.info("Computing average Response Time ....");
 
     if(method == 1) {
 	time = calibrate_method1(calibReqCallNo);
     } else if(method == 2) {
 	time = calibrate_method2(calibReqCallNo);
     } else if(method == 3) {
 	time = calibrate_method3(calibReqCallNo, BUFFER_SIZE);
     } else {
 	time = calibrate_method4(calibReqCallNo, BUFFER_SIZE);
     }
 
     if (log.isDebugEnabled()) log.info("Average Response Time for method " + method + " equals to " + time);
     return time;
   }
 
 
     private float calibrate_method1(int call_no) {
       int j=0;
       if( call_no<1 ) return 0;
       try {
 	long start = System.currentTimeMillis();
         for (j=1; j <= call_no; j++) {
           test.test();
         }
         return (System.currentTimeMillis() - start) / (float) call_no;
       } catch(Exception e) {
 	log.warn("Exception when calling method 2 no. " + j, e);
         return 0;
       }
     }
 
     private float calibrate_method2(int call_no) {
       int j=0;
       if( call_no<1 ) return 0;
       try {
 	long start = System.currentTimeMillis();
         for (j=1; j <= call_no; j++) {
           test.mtest();
         }
         return (System.currentTimeMillis() - start) / (float) call_no;
       } catch(Exception e) {
 	log.warn("Exception when calling method 2 no. " + j, e);
         return 0;
       }
     }
 
     
      private float calibrate_method3(int call_no, int size) {
       int j=0;
       if( call_no<1 ) return 0;
       byte[] buffer = new byte[size];
       try {
 	long start = System.currentTimeMillis();
         for (j=1; j <= call_no; j++) {
           test.test(buffer);
         }
         return (System.currentTimeMillis() - start) / (float)call_no;
       } catch(Exception e) {
 	log.warn("Exception when calling method 2 no. " + j, e);
         return 0;
       }
     }
 
 
     private float calibrate_method4(int call_no, int size) {
       int j=0;
       if( call_no<1 ) return 0;
       byte[] buffer = new byte[size];
       try {
 	long start = System.currentTimeMillis();
         for (j=1; j <= call_no; j++) {
           test.mtest(buffer);
         }
         return (System.currentTimeMillis() - start) / (float)call_no;
       } catch(Exception e) {
 	log.warn("Exception when calling method 2 no. " + j, e);
         return 0;
       }
     }
 
     
     private float test_method1(int call_no, long pauseTime) {
       int j=0;
       if( call_no<1 ) return 0;
       long reqStart, time = 0;
       try {
         for (j=1; j <= call_no; j++) {
 	  reqStart = System.currentTimeMillis();
           test.test();
 	  time += System.currentTimeMillis() - reqStart; 
 	  try{Thread.sleep(pauseTime); } catch(InterruptedException e) {}
         }
         return (float)time / call_no;
      } catch(RemoteException e) {
 	log.warn("Exception when calling method 2 no. " + j, e);
         return 0;
       }
     }
 
     private float test_method2(int call_no, long pauseTime) {
       int j=0;
       if( call_no<1 ) return 0;
       long reqStart, time = 0;
       try {
         for (j=1; j <= call_no; j++) {
 	  reqStart = System.currentTimeMillis();
           test.mtest();
 	  time += System.currentTimeMillis() - reqStart; 
 	  try{Thread.sleep(pauseTime); } catch(InterruptedException e) {}
         }
         return (float)time / call_no;
      } catch(RemoteException e) {
 	log.warn("Exception when calling method 2 no. " + j, e);
         return 0;
       }
     }
 
     
      private float test_method3(int call_no, long pauseTime, int size) {
       int j=0;
       if( call_no<1 ) return 0;
 
       byte[] buffer = new byte[size];
       long reqStart, time = 0;
       try {
         for (j=1; j <= call_no; j++) {
 	  reqStart = System.currentTimeMillis();
           test.test(buffer);
 	  time += System.currentTimeMillis() - reqStart; 
 	  try{Thread.sleep(pauseTime); } catch(InterruptedException e) {}
         }
         return (float)time / call_no;
       } catch(RemoteException e) {
 	log.warn("Exception when calling method 2 no. " + j, e);
         return 0;
       }
     }
 
 
     private float test_method4(int call_no, long pauseTime, int size) {
       int j=0;
       if( call_no<1 ) return 0;
 
       byte[] buffer = new byte[size];
       long reqStart, time = 0;
       try {
         for (j=1; j <= call_no; j++) {
 	  reqStart = System.currentTimeMillis();
           test.mtest(buffer);
 	  time += System.currentTimeMillis() - reqStart; 
 	  try{Thread.sleep(pauseTime); } catch(InterruptedException e) {}
         }
         return (float)time / call_no;
      } catch(RemoteException e) {
 	log.warn("Exception when calling method 2 no. " + j, e);
         return 0;
       }
     }
 } // END ClientTest