package NetLayout;

import java.util.*; // for StringTokenizer and Vector

public class Client extends Node {
  Stat reqIDTSt;  // statistics of request Inter-Departure Time
  Stat reqDocSt;  // statistics of request document size
  String traceFile;         // if trace data file is used
  int dnsID, lbaID, cacheServerID;
  Random rTime;
  Random rIndex;
  Random rHttpReqSize;
  double time;
  
  int docIndex;
  double httpReqSize;
  EventRecord er;
  public Client(Net net, int x, int y) {
    this.net = net;
    ID = net.objID++;
    net.addComponentDelay(ID);
    this.x = x;
    this.y = y;
    type = net.CLIENT;
    name =  "client" + net.objNo[type]++;
    reqIDTSt = new Stat();
    reqIDTSt.avg = 5; reqIDTSt.min = 2; reqIDTSt.max = 10;
    reqDocSt = new Stat();
    reqDocSt.avg = 5000; reqDocSt.min = 1000; reqDocSt.max = 500000;
    net.nodes.addElement(this);
  }
  public Client(Net net, StringTokenizer st, int type) {
    this.type = type;
    this.net = net;
    AttrValue av = new AttrValue(st);
    name = av.value;
    av = new AttrValue(st);
    ID = Integer.parseInt(av.value);
    net.addComponentDelay(ID);
    av = new AttrValue(st);
    x = Integer.parseInt(av.value);
    av = new AttrValue(st);
    y = Integer.parseInt(av.value);
    av = new AttrValue(st);
    traceFile = av.value;
    av = new AttrValue(st);
    dnsID = Integer.parseInt(av.value);
    av = new AttrValue(st);
    cacheServerID = Integer.parseInt(av.value);
    av = new AttrValue(st);
    lbaID = Integer.parseInt(av.value);
    // It would be nice to have regular expression. The code will be
    // much smaller.
    // System.out.println(" name="+name+" ID="+ID+" x="+x+" y="+y);
    try {
      av = new AttrValue(st);
      Double r = Double.valueOf(av.value);
      lon = r.doubleValue();
      av = new AttrValue(st);
      r = Double.valueOf(av.value);
      lat = r.doubleValue();
      av = new AttrValue(st);
      r = Double.valueOf(av.value);
      power = r.doubleValue();
      av = new AttrValue(st);
      r = Double.valueOf(av.value);
      reqIDTSt = new Stat();
      reqIDTSt.avg = r.doubleValue();
      av = new AttrValue(st);
      r = Double.valueOf(av.value);
      reqIDTSt.min = r.doubleValue();
      av = new AttrValue(st);
      r = Double.valueOf(av.value);
      reqIDTSt.max = r.doubleValue();
      av = new AttrValue(st);
      reqIDTSt.distType = Integer.parseInt(av.value);
      av = new AttrValue(st);
      r = Double.valueOf(av.value);
      reqDocSt = new Stat();
      reqDocSt.avg = r.doubleValue();
      av = new AttrValue(st);
      r = Double.valueOf(av.value);
      reqDocSt.min = r.doubleValue();
      av = new AttrValue(st);
      r = Double.valueOf(av.value);
      reqDocSt.max = r.doubleValue();
      av = new AttrValue(st);      
      reqDocSt.distType = Integer.parseInt(av.value);
    } catch (NumberFormatException e) {
      System.err.println("Could not convert string to double " + av.value);
    }
    localTime = 0.0;
    net.nodes.addElement(this);
    net.objNo[type]++;
    //System.out.println(toString());
  }
  public String toString() {
    return "type="+type+" name="+name+" ID="+ID+
      " x="+x+" y="+y+" "+" traceFile="+traceFile+
      " dnsID="+dnsID+" cacheServerID="+cacheServerID+" lbaID="+lbaID+
      " lon="+lon+" lat="+lat+" power="+power+
      " idtAvg="+reqIDTSt.avg+" idtMin="+reqIDTSt.min+" idtMax="+reqIDTSt.max+
      " idtType="+reqIDTSt.distType+
      " rdsAvg="+reqDocSt.avg+" rdsMin="+reqDocSt.min+" rdsMax="+reqDocSt.max+
      " rdsType="+reqDocSt.distType+
      linkListToString()+
      "\n";
  }

  public void eventHandle(EventRecord er) {

    double queueingTime = localTime - er.time;
      if (localTime < er.time) {
        localTime = er.time;
        queueingTime = 0.0;
      }
    String msgType = er.getField("msgType");
    if (msgType.compareTo("init") == 0) {
      System.out.println("recieved init event, generate http request\n");
      localTime = 0.0;
      rTime = new Random(ID);
      rIndex = new Random(ID+1);
      rHttpReqSize = new Random(ID+2);
      time = rTime.nextDouble()*(reqIDTSt.max-reqIDTSt.min)+reqIDTSt.min;
      // if use float constant attched f, f stands for single precision fp#
      er = new EventRecord(time, ID, ID, ID);
      er.addField("msgType", "http-request");
      net.println("put http-request in queue wake me up after "+time+"sec.");
      net.el.queueEvent(er);
    }
    if (msgType.compareTo("http-request") == 0) {
      net.println("recieved http-request event, generate http request\n");


      Link l = getFirstLink();  // find the cable connected to the client
      if (l == null) {
        System.out.println("This client is not connected to the network.");
        return;
      }
      docIndex = Math.abs(rIndex.nextInt())%net.noOfDocs;
      httpReqSize = rHttpReqSize.nextDouble()*(reqDocSt.max-reqDocSt.min)+reqDocSt.min;
      // calculate the transmission time
      double propagationTime = l.distance/net.signalPropagationSpeed;
      double transmissionTime = httpReqSize/l.bandwidth;
      time = localTime+transmissionTime+propagationTime;

      er.addField("startTime", ""+localTime);
      // save er.time since we are resuing the old init record as http-request er
      er.time = time;
      er.next = l.n2.ID;
      er.src = ID;
      er.dst = cacheServerID;
      er.addField("msgType", "http-request");
      er.addField("reqID", ""+net.getReqID());
      er.addField("docIndex", ""+docIndex);
      er.addField("msgSize", ""+httpReqSize);
      er.addField("route-qt", this.name+":0.0, ");

      double accQueueingTime = 0.0;
      er.addField("queueingTime", ""+accQueueingTime);

      double accMsgProcessingTime = (net.msgProcessingTime+httpReqSize/net.msgProcessingSpeed)/power;
      er.addField("msgProcessingTime", ""+accMsgProcessingTime);

      double accTransmissionTime = transmissionTime;
      er.addField("transmissionTime", ""+accTransmissionTime);

      double accPropagationTime = propagationTime;
      er.addField("propagationTime", ""+accPropagationTime);

      String s = ""+ID+":MPT="+accMsgProcessingTime+" "+
                 l.ID+":PT="+propagationTime+",TT="+transmissionTime;
      er.addField("componentDelay", s);


      // generate animation event if the animation flag is set on
      int p2x, p2y;
      if (net.animationOn) {
        if (l.n2.type == Net.MALINK) {
          p2x = l.x; p2y = l.y;
        } else {
          p2x = l.n2.x+16; p2y = l.n2.y+16;
        }
        net.animate(er, localTime, propagationTime, x+16, y+16, p2x, p2y);
      }

      net.el.queueEvent(er);
      net.println("time="+localTime+" name="+name+" sends reqID="+er.getField("reqID")+" msgSize="+httpReqSize);


      // generate next http-request event record
      time = localTime+rTime.nextDouble()*(reqIDTSt.max-reqIDTSt.min)+reqIDTSt.min;
      EventRecord newer = new EventRecord(time, ID, ID, ID);
      newer.addField("msgType", "http-request");
      net.println("time="+localTime+" name="+name+" put http-request in queue wake me up after "+time+"sec.");
      net.el.queueEvent(newer);
      }
    if (msgType.compareTo("http-response") == 0) {

      totalQueueingTime += queueingTime;
      noOfRequests++;
     try {
      Double d = Double.valueOf(er.getField("retrieveTime"));
      double retrieveTime = d.doubleValue();
      
      d = Double.valueOf(er.getField("queueingTime"));
      double accQueueingTime = d.doubleValue();
      accQueueingTime += queueingTime;

      Double r = Double.valueOf(er.getField("msgSize"));
      double msgSize = r.doubleValue(); 
      double msgProcessingTime = (net.msgProcessingTime+msgSize/net.msgProcessingSpeed)/power;
      d = Double.valueOf(er.getField("msgProcessingTime"));
      double accMsgProcessingTime = d.doubleValue();
      accMsgProcessingTime += msgProcessingTime;

      d = Double.valueOf(er.getField("transmissionTime"));
      double accTransmissionTime = d.doubleValue();

      d = Double.valueOf(er.getField("propagationTime"));
      double accPropagationTime = d.doubleValue();


      localTime += (net.msgProcessingTime+msgSize/net.msgProcessingSpeed)/power+
                    queueingTime;
      net.println("*** time="+localTime+" name="+name+" relay reqID="+er.getField("reqID")+" msgSize="+msgSize);

      d = Double.valueOf(er.getField("startTime"));
      double startTime = d.doubleValue();
      double endToEndRespTime = localTime - startTime;

      net.println("*** endToEndResptime="+endToEndRespTime);
      net.println("*** accQueueingTime="+accQueueingTime+
            ", percentage="+accQueueingTime*100.0/endToEndRespTime);
      net.println("*** accMsgProcessingTime="+accMsgProcessingTime+
            ", percentage="+accMsgProcessingTime*100.0/endToEndRespTime);
      net.println("*** accTransmissionTime="+accTransmissionTime+
            ", percentage="+accTransmissionTime*100.0/endToEndRespTime);
      net.println("*** accPropagationTime="+accPropagationTime+
            ", percentage="+accPropagationTime*100.0/endToEndRespTime);
      net.println("*** retrieveTime="+retrieveTime+
            ", percentage="+retrieveTime*100.0/endToEndRespTime);

      net.println("*** route-qt="+er.getField("route-qt")+", "+name+":"+queueingTime);
      net.totalEndToEndRespTime += endToEndRespTime;
      net.noOfFinishedRequests++;

      // componentDelayAnalysis
      String cds = er.getField("componentDelay");
      String clientCDS = " "+ID+":QT="+queueingTime+",MPT="+msgProcessingTime;
      ComponentDelayList cdl = new ComponentDelayList(net, ""+net.noOfFinishedRequests, cds+clientCDS);
      // net.logPrintln("local seesion CDA:\n"+cdl.toString());
      net.addComponentDelayList(cdl);
      net.logPrintln("===Request "+net.noOfFinishedRequests+": "+cds+clientCDS);
      if (net.noOfFinishedRequests%100==1) {
        net.logPrintln("local session CDA:\n"+cdl.toString());
        net.cdl.sort();
        net.logPrintln("Global List CDA:\n"+net.cdl.toString());
      }
     } catch (NumberFormatException e) {
      System.err.println("Client.java: Could not convert string to double " + e.toString());
      net.logPW.close();
      System.exit(1);
     }
    
    }
  }
  
}