//Title:        Simulator for network bandwidth measurement
//Version:
//Copyright:    Copyright (c) 1998
//Author:       xhe
//Company:      UCCS

package Simulator;

//import java.awt.*;
//import java.awt.event.*;
import java.io.*;
import java.util.*;
//import java.swing.*;

public class Simulator extends NetworkConfigure {
  /*Router [] Routers;
  Link [] Links;
  EventsQueue EQ;
  RouterTable [] RoadTable; */
  Chart chart;

  /* old one
  double msgProcessingTime=0.0001; // 0.1 msec
  double msgProcessingSpeed= 1.0E+6; //1MBps
  double RouterBandwidth = 1.0E+9;
  double LinkBandwidth = 1.0E+7;  // 10MBps
  double signalPropagationSpeed = 2.0E+8;  // fiber speed


  double msgProcessingTime=0.0001; // 0.1 msec
  double msgProcessingSpeed= 1.5E+7; //15MBps make ture that the 10M bandwidth
  double RouterBandwidth = 1.0E+9;
  double LinkBandwidth = 1.0E+7;  // 10MBps
  double signalPropagationSpeed = 2.0E+8;  // fiber speed
  */

  int numOfRouter;  // how many router
  int numOfLink;    // how many link
  int numOfRoad;    // how many different router road
  //int TPSize;       // traffic message size, unit is bits.
  int MaxMessNum=0;   // the maximum message number
  int ProbingMessNum; // how many probing mess needed in one probe

  double PInternalTime; // Probing Message sending interval time in one probing cycle
  double TInternalTime; // Traffic Message sending interval time
  //double TBIntervalTime; // Traffic Bandwidth checking Interval Time
  double PBIntervalTime; // Probing Interval Time between two probing cycle
  double RoundTripTime=0.0;   // the round trip time of a message with no congestion

  // the following two variable for Cprobing use
  // double CPIntervalTime;  // Cprobing interval time between two probing cycle
  int CprobingNum=0;        // How many message in one Cprobing cycle

  Link BottleneckLink;  // the bottleneck link
  PrintWriter LogFile;  // log file
  PrintWriter PFile;  // log file for probing message
  PrintWriter EventFile;  // log file for events

  int Start_MeaTime;  // when the start of the probing
  int end_time;       // when the end of the probing
  boolean NeedTraffic = false;  // not for cprobing statistics

  // what kind of probing method results need to show in the chart
  boolean Single_probing = false;   // single message probing
  boolean Cprobing = false;         // cprobing
  boolean Adaptive_probing = false; // Adaptive probing

  public Simulator() {
    try  {
      jbInit();
    }
    catch (Exception e) {
      e.printStackTrace();
    }
  }

  public static void main(String[] args) {
    Simulator simulation = new Simulator();
  }

  private void jbInit() throws Exception {
    StringTokenizer t;
    Double DTemp;

    rnd = new Random();
    chart = new Chart();

    // warm up random number generator
    for (int index=0; index<50000; index++)
      rnd.nextInt();

    EQ = new EventsQueue();

    try {
      BufferedReader ifile = new BufferedReader(new FileReader("configure.txt"));
      String s;
      int iterate=0;

      // first line for four parameters of PInternalTime, PBIntervalTime
      // TInternalTime and TBIntervalTime
      s = ifile.readLine();
      t = new StringTokenizer(s,"|");

      DTemp = Double.valueOf(t.nextToken());
      PInternalTime = DTemp.doubleValue();
      DTemp = Double.valueOf(t.nextToken());
      PBIntervalTime = DTemp.doubleValue();
      DTemp = Double.valueOf(t.nextToken());
      TInternalTime = DTemp.doubleValue();
      DTemp = Double.valueOf(t.nextToken());
      TBIntervalTime = DTemp.doubleValue();

      // second line for five number: how many Router, Link and Road,
      // the fourth number is the number of the bottleneck Link
      // the fifth number is the number of how many probing message in one probing route
      s = ifile.readLine();
      t = new StringTokenizer(s,"|");
      numOfRouter = Integer.parseInt(t.nextToken());
      numOfLink = Integer.parseInt(t.nextToken());
      numOfRoad = Integer.parseInt(t.nextToken());

      Routers = new Router[numOfRouter+1];
      Links = new Link[numOfLink+1];
      RoadTable = new RouterTable[numOfRoad];

      // generate all the routers: range starts from 1
      for(int i=1; i<= numOfRouter; i++)
        Routers[i] = new Router(this,i);

      // generate all the links: range starts from 1
      for(int i=1; i<= numOfLink; i++) {
        int distance = rnd.nextInt(1000)+3;   // a random link distance;
        Links[i] = new Link(this,distance,i,true);
      }

      BottleneckLink = Links[Integer.parseInt(t.nextToken())];
      BottleneckLink.BottleneckLink = true; // set the field
      // retrieve how many messages needed in one probing cycle
      ProbingMessNum = Integer.parseInt(t.nextToken());

      // retrieve how many messages needed in one Cprobing cycle
      CprobingNum = Integer.parseInt(t.nextToken());

      // create the router table, start from 0
      // each line after third line(included) is a single road table
      while (iterate < numOfRoad) {
        s = ifile.readLine();
        t = new StringTokenizer(s,"|");
        int RoadNodeNum = t.countTokens();

        RoadTable[iterate] = new RouterTable(iterate,RoadNodeNum);

        int num=0;
        String tmp;
        while (num < RoadNodeNum){
          tmp = t.nextToken();

          if (tmp.charAt(0) == 'L')   // this is a link object
            RoadTable[iterate].append(Links[Integer.parseInt(tmp.substring(1))],num);
          else
            RoadTable[iterate].append(Routers[Integer.parseInt(tmp.substring(1))],num);

          num++;
        } // end of one single line, inner while
        iterate ++;
      } // end of all road table, outer while

      ifile.close();
    }
    catch (IOException d) {
      System.out.print("Error" + d);
      System.exit(1);
    }
    pareto = new Pareto();
    weibull = new Weibull();

    Start_MeaTime = 4;
    end_time = 10;
    //traffic = new Traffic(2,"Flat");
    //traffic = new Traffic("Web");
    traffic = new Traffic("Slope",false,9,1,Start_MeaTime,end_time,TBIntervalTime);
    NeedTraffic = true;

    // what kind of probing method you need to show
    Single_probing = true;   // single message probing
    Cprobing = true;         // cprobing
    Adaptive_probing = false; // Adaptive probing

    // start simulation
    start_simulation();
  }

  private void start_simulation() {
    // open a log file for the writing of simulator
    try {
      LogFile = new PrintWriter(new FileWriter("log.txt"));
      PFile = new PrintWriter(new FileWriter("probing.txt"));
      //EventFile = new PrintWriter(new FileWriter("Events.txt"));
    }
    catch(IOException k) {
      System.out.print("Error" + k);
      System.exit(1);
    }

    // there is only one probing agent.
    // The first router of the first road is the probing agent.
    // the first router in each of the rest roads is the traffic generation agent.
    Message M,NewM;
    double Start_TrafficTime = 0.1;
    //double Start_TrafficTime = 6.0;

    // initializing the start event
    // for the probing agent
    // generate the initial probing message, size is static value 46 bytes
    M = new Message(0,0,"Probe-start",46*8,Start_MeaTime); // the message nubmer is useless.
    //M = new Message(0,0,"Probe-start",46*8,0); // the message nubmer is useless.
    EQ.insert(M);

    // Generate one "RoundTripTime-Probing" type messages
    // to measure the relatively accurate round trip time for a message
    // the probing agent sends this type message always.
    // This probing message is declared with traffic message constructor
    // because the queuing time at each object of its route is 0.0
    M = new Message(0,0,"RoundTripTime-ProbingRequest",46*8,0.0);
    //M = new Message(0,0,"RoundTripTime-ProbingRequest",46*8,6.0);
    EQ.insert(M);

    // Generate the first "Traffic-start" type message
    // time 0.0 means this is the first one
    // always the first traffic agent is to use it to set the bottleneck
    M = new Message(0,1,"Traffic-start",46*8,Start_TrafficTime);
    EQ.insert(M);

    for (int j=2; j<numOfRoad; j++) // for each traffic agent
    {
      // generate the initial traffic message
      M = new Message(0,j,"New-TrafficMess",46*8,Start_TrafficTime);
      EQ.insert(M);
    }

    // generate the last "Simulation-end" message
    // all arguments except the data type are useless.
    M = new Message(0,0,"Simulation-end",8,end_time);
    EQ.insert(M);

    int Sented_ProbingMess = 0; // keep track of how many probing message already been sent
    int Sent_CprobingMess = 0; // keep track of how many Cprobing message already been sent
    double SendingTime=0.0;   // for Cproing Message use
    long SizeOfSent=0;    // the sum of Cprobing message size

    chart.display(Start_MeaTime,end_time);

    // start event dispatching
    while ((M = EQ.nextItem()) != null) {
      boolean flag = false;
      String MessageType = M.MessageType;

      if (MessageType.compareTo("Simulation-end") == 0) {
          PFile.close();
          LogFile.close();

          // close all the opened file in Router
          for(int i=1; i<= numOfRouter; i++)
            Routers[i].OFILE.close();

          // close all the opened file in Link
          for(int i=1; i<= numOfLink; i++)
            Links[i].OFILE.close();


          //EventFile.close();
          System.out.println("Simulation End");
          try {
            System.in.read();
          }
          catch (IOException d) {
            System.out.print("Error" + d);
            System.exit(1);
          }
          System.exit(0);
      }

      if (MessageType.compareTo("RoundTripTime-ProbingRequest") == 0) {
        // wakeup the corresponding object to handle this message
        // set the wakeup time of the message next time.
        // this setted time is stored in the Backup_nextArrivalTime
        RoadTable[M.RouterTableNum].Node(M.NextObjectIndex).EventHandler(M);
        EQ.insert(M);

        flag = true;
      }

      if (!flag && (MessageType.compareTo("RoundTripTime-ProbingResponse") == 0)) {
        // wakeup the corresponding object to handle this message
        // set the wakeup time of the message next time.
        /* double old_ArrivalTime = M.getArrivalTime(); */
        boolean responseMess_GetToDestination =
                RoadTable[M.RouterTableNum].Node(M.NextObjectIndex).EventHandler(M);

        if  (!responseMess_GetToDestination)
          EQ.insert(M); // The response message does not reach its source
        else {
          RoundTripTime = M.getArrivalTime();
          LogFile.println("Round Trip Time: "+ RoundTripTime);
        }

        flag = true;
      }

      if (MessageType.compareTo("Traffic-start") == 0) {
          // there is only one Traffic-start message, it starts generating general traffic

          // generate a new traffic message
          // the message type is "HTTP-request"
          NewM = new Message(++MaxMessNum,M.RouterTableNum,"HTTP-request",traffic.TrafficMessSize,M.getArrivalTime());
          RoadTable[NewM.RouterTableNum].Node(NewM.NextObjectIndex).EventHandler(NewM);
          EQ.insert(NewM);

          BottleneckLink.Tstarting_time = M.getArrivalTime();
          BottleneckLink.Transfered_bit = 0;     // a new measure cycle
          //BottleneckLink.updated = true;
          BottleneckLink.end_time = M.getArrivalTime()+TBIntervalTime;

          // change M type to a new traffic generation message: "New-TrafficMess"
          // wakeup me to generate the next traffic message in one traffic route
          // message number is useless.
          M.MessageType = "New-TrafficMess";
          M.setTime(M.getArrivalTime()+TInternalTime);
          EQ.insert(M);

          flag = true;
      }

      if (!flag && (MessageType.compareTo("New-TrafficMess") == 0)) {
          // traffic agent generates a new traffic message
          // generate the next traffic message generation message

          // generate a new traffic message
          // change the message type to "HTTP-request"
          //NewM = new Message(++MaxMessNum,M.RouterTableNum,"HTTP-request",(rnd.nextInt(2400)+100)*8,M.getArrivalTime());
          ++MaxMessNum;
          NewM = new Message(MaxMessNum,M.RouterTableNum,"HTTP-request",traffic.TrafficMessSize,M.getArrivalTime());
          //NewM = new Message(++MaxMessNum,M.RouterTableNum,RoadTable[M.RouterTableNum].numOfNode,
          //                    M.getArrivalTime(),"HTTP-request",(rnd.nextInt(1900)+100)*8,M.getArrivalTime());
          RoadTable[NewM.RouterTableNum].Node(NewM.NextObjectIndex).EventHandler(NewM);
          EQ.insert(NewM);

          // set next "New-TrafficMess" generation time
          // wakeup me to generate the next new traffic message
          M.setTime(M.getArrivalTime()+TInternalTime);
          EQ.insert(M);

          flag = true;
      }

      if (!flag && (MessageType.compareTo("Probe-start") == 0)) {
          // probing agent generates a new probing route
          // generate the next probing message generation message
          // set the next probing start message time
          // let the bottleneck link reset the start time to measure bandwidth
          // probing message number always from 1 to ProbingMessNum
          //BottleneckLink.Pstarting_time = M.getArrivalTime();

          // generate a new probing message: "ICMP-request"
          Sented_ProbingMess++;
          NewM = new Message(Sented_ProbingMess,M.RouterTableNum,RoadTable[M.RouterTableNum].numOfNode,
                              M.getArrivalTime(),"ICMP-request",46*8,M.getArrivalTime(),0);
          RoadTable[NewM.RouterTableNum].Node(NewM.NextObjectIndex).EventHandler(NewM);
          EQ.insert(NewM);

          // create next new probing generation message: "New-ProbingMess"
          // wakeup me to generate the next new probing message
          // message number is useless.
          NewM = new Message(0,M.RouterTableNum,"New-ProbingMess",M.getSize(),
              M.getArrivalTime()+PInternalTime);
          EQ.insert(NewM);

          // generate the next "Probing-start" message
          M.setTime(M.getArrivalTime()+PBIntervalTime);
          EQ.insert(M);

          flag = true;
      }

      if (!flag && (MessageType.compareTo("New-ProbingMess") == 0)) {
          // probing agent generates a new probing message
          // generate the next probing message generation message

          // generate a new probing message
          // change the message type to "ICMP-request"
          Sented_ProbingMess++;
          NewM = new Message(Sented_ProbingMess,M.RouterTableNum,RoadTable[M.RouterTableNum].numOfNode,
                              M.getArrivalTime(),"ICMP-request",46*8,M.getArrivalTime(),0);
          RoadTable[NewM.RouterTableNum].Node(NewM.NextObjectIndex).EventHandler(NewM);
          EQ.insert(NewM);

          if (Sented_ProbingMess == ProbingMessNum) { // finish one probing route
            Sented_ProbingMess = 0;

            // A new Cprobing cycle always starts immidately after the normal probing cycle ends
            SendingTime = M.getArrivalTime();
            Sent_CprobingMess++;

            // generate the first Cprobing mess in the next Cprobing cycle
            NewM = new Message(Sent_CprobingMess,M.RouterTableNum,RoadTable[M.RouterTableNum].numOfNode,
                              SendingTime,"CP-request",rnd.nextInt(6000)+6000,M.getArrivalTime(),0);
            RoadTable[NewM.RouterTableNum].Node(NewM.NextObjectIndex).EventHandler(NewM);
            EQ.insert(NewM);
            SizeOfSent = SizeOfSent + NewM.getSize();

            // create next new Cprobing generation message: "New-CProbingMess"
            // wakeup me to generate the next new cprobing message
            // there are no time gap between two Cprobing message in one Cproing Cycle
            Message NewM1 = new Message(0,M.RouterTableNum,"New-CProbingMess",M.getSize(),NewM.getArrivalTime());
            EQ.insert(NewM1);
          }
          else {
            // set the current message time to generation
            // the next "New-ProbingMess" message
            M.setTime(M.getArrivalTime()+PInternalTime);
            EQ.insert(M);
          }

          flag = true;
      }

      if (!flag && (MessageType.compareTo("New-CProbingMess") == 0)) {
          // probing agent generates a new Cprobing message
          // create the next Cprobing message generation message

          // generate a new Cprobing message
          // change the message type to "ICMP-request"
          Sent_CprobingMess++;
          NewM = new Message(Sent_CprobingMess,M.RouterTableNum,RoadTable[M.RouterTableNum].numOfNode,
                              M.getArrivalTime(),"CP-request",rnd.nextInt(6000)+6000,M.getArrivalTime(),0);
          RoadTable[NewM.RouterTableNum].Node(NewM.NextObjectIndex).EventHandler(NewM);
          EQ.insert(NewM);

          if (Sent_CprobingMess == CprobingNum) { // finish one Cprobing route
            Sent_CprobingMess = 0;

            // the last mess in one Cprobing cycle is special
            // its SizeOfSented field is the sum of all the Cprobing mess size in this cycle\
            // its Pstarting_time field is the staring time of when the first Cprobing mess
            // is sent in the current Cprobing cycle
            NewM.SizeOfSented = SizeOfSent + NewM.getSize();
            NewM.Pstarting_time = SendingTime;
            SizeOfSent = 0;
          }
          else {
            // set the current message time to generation
            // the next "New-ProbingMess" message
            // there are no time gap between two Cprobing message in one Cproing Cycle
            SizeOfSent = SizeOfSent + NewM.getSize();
            M.setTime(NewM.getArrivalTime());
            EQ.insert(M);
          }

          flag = true;
      }

      if (!flag && (MessageType.compareTo("New-WebMess") == 0)) {
          double AT = M.getArrivalTime();

          // generate a new web request message: "HTTP-request"
          NewM = new Message(++MaxMessNum,M.RouterTableNum,"HTTP-request",46*8,AT);
          RoadTable[NewM.RouterTableNum].Node(NewM.NextObjectIndex).EventHandler(NewM);
          EQ.insert(NewM);


          // reset the next web message generation time
          // the time is got by pareto distribution
          double Fx = rnd.nextDouble();
          double lowerBound = 1.0;
          alpha = 1.5;
          double gap = pareto.getX(Fx,lowerBound,alpha);

          M.setTime(AT+gap);
          EQ.insert(M);

          flag = true;
      }

      if (!flag && (MessageType.compareTo("HTTP-request") == 0)) {
          // wakeup the corresponding object to handle this message
          // set the wakeup time of the message next time.
          boolean responseMess_GetToDestination =
            RoadTable[M.RouterTableNum].Node(M.NextObjectIndex).EventHandler(M);

          if (!responseMess_GetToDestination)
            EQ.insert(M);

          flag = true;
      }

      if (!flag && (MessageType.compareTo("ICMP-request") == 0)) {
          // wakeup the corresponding object to handle this message
          // set the wakeup time of the message next time.
          RoadTable[M.RouterTableNum].Node(M.NextObjectIndex).EventHandler(M);
          EQ.insert(M);

          flag = true;
      }

      if (!flag && (MessageType.compareTo("CP-request") == 0)) {
          // wakeup the corresponding object to handle this message
          // set the wakeup time of the message next time.
          RoadTable[M.RouterTableNum].Node(M.NextObjectIndex).EventHandler(M);
          EQ.insert(M);

          flag = true;
      }

      // "HTTP-response" message type is only shown up in Web traffic pattern
      if (!flag && (MessageType.compareTo("HTTP-response") == 0)) {
          // wakeup the corresponding object to handle this message
          // set the wakeup time of the message next time.
          //double old_ArrivalTime = M.getArrivalTime();
          boolean responseMess_GetToDestination =
                RoadTable[M.RouterTableNum].Node(M.NextObjectIndex).EventHandler(M);

          if  (!responseMess_GetToDestination)
            EQ.insert(M); // The response message does not back to its source

          flag = true;
      }

      if (!flag && (MessageType.compareTo("ICMP-response") == 0)) {
          // wakeup the corresponding object to handle this message
          // set the wakeup time of the message next time.
          //double old_ArrivalTime = M.getArrivalTime();
          boolean responseMess_GetToDestination =
                RoadTable[M.RouterTableNum].Node(M.NextObjectIndex).EventHandler(M);

          if  (!responseMess_GetToDestination)
            EQ.insert(M); // The response message does not back to its source
          else {
            double Measued_Band = (46*8)/(M.getArrivalTime() - M.Pstarting_time - RoundTripTime);
            PFile.println("Starting time: " + M.Pstarting_time);
            for (int i=0; i<RoadTable[M.RouterTableNum].numOfNode*2-1; i++) {
              PFile.println(i+":  "+M.QueuingTime[i]);
            }
            PFile.println("Receiving time: " + M.getArrivalTime());
            PFile.println();

            LogFile.println("Probing start Time: "+ M.Pstarting_time +
                "  End Time: " + M.getArrivalTime() + "   Measured BandWidth: "+
               Measued_Band);

            chart.Pupdate(M.getArrivalTime(),Measued_Band*10/LinkBandwidth);
          }

          flag = true;
      }

      if (!flag && (MessageType.compareTo("CP-response") == 0)) {
          // wakeup the corresponding object to handle this message
          // set the wakeup time of the message next time.
          //double old_ArrivalTime = M.getArrivalTime();
          boolean responseMess_GetToDestination =
                RoadTable[M.RouterTableNum].Node(M.NextObjectIndex).EventHandler(M);

          if  (!responseMess_GetToDestination)
            EQ.insert(M); // The response message does not back to its source
          else {
            if (M.MessNum == CprobingNum)  { // the last one return
              double Measued_Band = M.SizeOfSented / (M.getArrivalTime() - M.Pstarting_time);

              LogFile.println("CProbing start Time: "+ M.Pstarting_time +
                  "  End Time: " + M.getArrivalTime() + "   Measured BandWidth: "+
                  Measued_Band);

              chart.Cupdate(M.getArrivalTime(),Measued_Band*10/LinkBandwidth);
            }
          }
      }

      //EventFile.println(M.MessageType + " :  " + M.getArrivalTime() +"|"+M.MessNum);
      EQ.remove(); // remove the first message from the event queue
    } // end of while
  }

  public void UpdateLog (double output_time) {

    // initialize the Tcurx and Tcury
    if ((output_time - Start_MeaTime) < 1.0E-7) {
      double Available_BandWidth = LinkBandwidth - (BottleneckLink.Transfered_bit/TBIntervalTime);
      LogFile.println("Starting Time: "+ BottleneckLink.Tstarting_time +
                  "  End Time: " + output_time + "   Available BandWidth: "+
                  Available_BandWidth);
      chart.Tcurx = chart.PosXConversion(output_time);
      chart.Tcury = chart.PosYConversion((Available_BandWidth*10/LinkBandwidth));
    }

    if (output_time > Start_MeaTime) {  // update the chart
      double Available_BandWidth = LinkBandwidth - (BottleneckLink.Transfered_bit/TBIntervalTime);
      LogFile.println("Starting Time: "+ BottleneckLink.Tstarting_time +
                 "  End Time: " + output_time + "   Available BandWidth: "+
                  Available_BandWidth+"  |  " + BottleneckLink.Transfered_bit);
      chart.Tupdate(output_time,Available_BandWidth*10/LinkBandwidth);
    }

    traffic.ArguChange(output_time > Start_MeaTime);
  }

  public void end_simulation() {
    System.exit(0);
  }
}