/*
 * Client.java
 *
 * client data and operations 
 *
 *  Created by: Arthur L. Blais
 *              Visteon/Ford Microelectronics Inc.
 *              Colorado Springs, CO
 *
 *  Date: Fri Sep 24 08:43:13 MDT 1999
 *
 ****************************************************************************
 *
 * Notes and Acknowledgments:
 *
 * Active and Inactive off times and the number of embeded references are 
 * generated from distributions modeled by Barford and Crovella at Boston
 * University. Inactive off times represent think time by the client is
 * represented by a pareto distribution. The number of embedded references
 * is also represented by a pareto distribution. The The values for alpha
 * and k (lowerBound) were fitted the pareto distribution to measured data.
 * The Inactive off times, the time between embeded references is 
 * represented with a Weibull distribution with an alpha an beta value
 * fitted to measured data.
 * Paul A. Barford and Mark Crovella, Generating Representitive Web
 * Workloads for Network and Server Performance Evaluation, Technical 
 * Paper BU-CS-07-006, Boston University, December 31, 1997
 *
 ****************************************************************************
 *
 *   Class Methods
 *
 *
 ****************************************************************************
 */
 
import java.io.*;
import java.util.*;
import java.text.NumberFormat;


public class Client {

  private Request request;               // current request
  private long numberOfReferences = 0;   // number of embeded requests
  private long totalResponseTime = 0;    // sum of all response times
  private long totalExecutionTime = 0;   // sum of all request exec times
  private long requestCount = 0;         // number of requests made
  private long bytesReceived = 0;        // total bytes received
  private int id;                        // client id
  private int lbm;                       // clients load balancing manager
  private long wakeUpTime;               // client wake up time
  private long asleepTime;               // time client goes to sleep
  static Random randomNumber;            // psuedo random number generator 
 
  // statistical variables per interval
  private long lastRequestCount;
  private long lastBytesReceived;
  private long lastResponseTime;

  // constructor
  public Client( int i, int l, long w, long s, long seed ) {
    id = i;
    lbm = l;
    wakeUpTime = w;
    asleepTime = s;
    randomNumber = new Random( seed );
  }
  
  /**
   * getId
   *
   * return this client's id number
   */
  int getId() {

    return id;
  }

  /**
   * getLbm
   *
   * returns the client's lbm
   */
  int getLbm() {

    return lbm;
  }

  /**
    * newRequest
    */
  void newRequest( Request r ) {
    request = r;
    requestCount++;
  }
    
  /**
    * getRequest
    *
    * return the current request
    */
  Request getRequest() {
    return request;
  }


  /**
    * deleteRequest
    *
    * delete the current request
    */
  void deleteRequest() {
    request = null;
  }

  /**
    * getRequestCount
    */
  long getRequestCount() {
    return requestCount;
  }

  /**
    * getResponseTime
    */
  long getResponseTime() {
    return totalResponseTime;
  }  

  /**
   * getBytesReceived
   */
  long getBytesReceived() {
    return bytesReceived;
  }

  /**
   * updateStats
   *
   */
  void updateStats( Request r ) {

    totalResponseTime += r.getWaitTime();
    totalExecutionTime += r.getExecutionTime();
    bytesReceived += r.getSize();
  }

  /**
    * getExecutionTime
    */
  long getExecutionTime() {
    return totalExecutionTime;
  }

  /**
   * getNextRequestTime
   *
   * Calculates the next time a request is to be made.
   * 
   * Inactive off time (includes think time) is first calcuated.
   * Once a reqeust has been made, the reqeust time is calculate
   * foreach embedded references.
   *
   */
  long getNextRequestTime( long t ) {
 
    double lowerBound;
    double alpha;
    double beta;
    double tailStart = 0.95;
    double x;
    long sleepTime;
    long requestTime;

    double Fx = randomNumber.nextDouble();

    if ( numberOfReferences == 0 ) {

      sleepTime = getSleepTime( t );
 
      if ( sleepTime == 0  ) {
        // inactive off time, but client is awake (i.e. think time)
        lowerBound = 1.0;
        alpha = 1.5;

        x = Pareto.getX( Fx, lowerBound, alpha );

	// get the number of ebedded references
        alpha = 2.43;
        Fx = randomNumber.nextDouble();
        numberOfReferences = ( long ) Pareto.getX( Fx, lowerBound, alpha );
      }
      else { 
	// client is asleep
        return ( sleepTime );
      } 
    }   
    else {
      // active off time, returns milliseonds
      alpha = 1.46;
      beta = 0.382;
   
      numberOfReferences--;
      x = Weibull.getX( Fx, alpha, beta );

    }

    // convert to milliseconds
    requestTime = ( long ) ( x * 1000.0 );   
    
    return ( requestTime );
  }



  /**
   * getSleepTime
   *
   * Return 0 if client is awake 
   * else return time to sleep
   */
  long getSleepTime( long t ) {

    long sleepTime;                           // milliseconds to sleep
    long timeToWakeUp;                        // wake up time (ms)
    long msph = 3600000;                      // milliseconds per hour
    long ms = t / msph;                       // milliseconds in current hour
    long timeOfDay = ( t / msph ) % 24;       // time (hour) in current day
    

    if ( timeOfDay >= wakeUpTime && timeOfDay <= asleepTime ) {
      // client is awake
      sleepTime = 0;
    }
    else if ( timeOfDay < wakeUpTime ) {

      timeToWakeUp = wakeUpTime * msph;
      sleepTime = timeToWakeUp - ( ( timeOfDay * msph ) + ms );
    }
    else {

      timeToWakeUp = ( wakeUpTime + 24 ) * msph;
      sleepTime = timeToWakeUp - ( ( timeOfDay * msph ) + ms );
    } 

    return sleepTime;
  }



  /**
   * getIdleTime
   */
  long getIdleTime( long t ) {
    return  ( t - totalExecutionTime - totalResponseTime );
  }

  /**
   * printStats
   */
  void printStats( long statTime, FileWriter f ) throws IOException {

    long statRequestCount;
    long idleTime;
    long avgSize;
    double avgResponseTime;
    double avgIdleTime;
    double avgExecutionTime;
    long currentRequestCount;
    long currentBytesReceived;
    double currentResponseTime;
    long hour = ( statTime / 3600000 ) % 24;
    long reportTime = statTime / 1000;

    NumberFormat nf = NumberFormat.getInstance( Locale.US );
    nf.setMaximumFractionDigits( 4 );

    if ( request == null ) {
      statRequestCount = requestCount;
    }
    else {
      statRequestCount = requestCount - 1;
    }

    // total stats
    idleTime = statTime - totalExecutionTime - totalResponseTime;

    if ( statRequestCount > 0 ) {
      avgSize = bytesReceived / statRequestCount;
      avgResponseTime = ( ( double ) totalResponseTime / 1000.0 ) / 
	                  ( double ) statRequestCount;                // seconds
      avgExecutionTime = ( ( double ) totalExecutionTime / 1000.0 ) / 
                           ( double ) statRequestCount;               // seconds
    }
    else {
      avgSize = 0;
      avgResponseTime = 0;
      avgExecutionTime = 0;
    }

    // interval stats
    currentRequestCount = statRequestCount - lastRequestCount;
    currentBytesReceived = bytesReceived - lastBytesReceived;

    if ( currentRequestCount > 0 ) {
      currentResponseTime = ( ( double ) ( totalResponseTime - lastResponseTime ) / 1000.0 ) /
                            ( double ) currentRequestCount;   
    }
    else {
       currentResponseTime = 0;
    }
      
    String outputStr = id + "\t" + lbm + "\t" + hour + "\t" + reportTime + "\t" +  
                       statRequestCount + "\t" + currentRequestCount + "\t" +  
                       bytesReceived +  "\t" + currentBytesReceived + "\t" + 
                       avgSize + "\t" + 
                       nf.format( avgResponseTime ) + "\t" + 
                       nf.format( currentResponseTime );
    //                 nf.format( avgExecutionTime ) + "\t" + 
    //                 idleTime + "\t" + 
    //                 totalResponseTime + "\t" + 
    //                 totalExecutionTime;

    lastRequestCount = statRequestCount;
    lastBytesReceived = bytesReceived;
    lastResponseTime = totalResponseTime;

    if ( f != null ) {

      f.write( outputStr );
      f.write( "\n" );
      f.flush();
    }
    else {
      System.out.println( outputStr );
    }

  }  // printStats

}