/** A class used to run the simulation and output data on it
    @author Erika Harrison
    @version 1.0 24-06-02
*/
import java.text.DecimalFormat;
import java.applet.Applet;
import java.util.Vector;

public class Simulation extends Applet
{  //used for statistical purposes
   private Queue students = DataFactory.makeQueue();
   private int studentCount = 0;
   private double time = 0;

   //the time at which the stats for the queues is initiated
   private double statsStart = 0;

   //the different servers in the system
   private Server[] servers = new Server[Constants.NUM_SERVERS];

   //for counting purposes
   private int NUM_TIMES;
   private int START_STATS;

   private int nextServer = 0;
   private int enqueue = 0;
   private int dequeue = 0;

   private String[] array = new String[13];

   public Simulation()
   {  super();
/**
      for (int x = 1; x < 3; x++)
      { init();
      setValues(10, 20, 30, 40, 50, 10, 20, 10, 20, 50, 5 * x, 2);

      while (students.size() < NUM_TIMES)
      {  runNextEvent();
         System.out.println(getEnqueue() + " " + getDequeue());
      }

      int counter = 0;

      while (counter < 5)
      {  runNextEvent();
         System.out.println(getEnqueue() + " " + getDequeue());
         counter++;
      }

      System.out.println("Num times " + NUM_TIMES);
      System.out.println("Students size " + students.size());

      String[] values = calcEvents();
      System.out.println("Length " + values.length);
      for (int i = 0; i < values.length; i++)
      {  System.out.print(values[i] + " ");
      }
      System.out.println("");
      }
      */
   }

   public void start()
   {  init();
   }

   public static void main(String[] args)
   {  Simulation s = new Simulation();
   }

   public void init()
   {  //constructs a new simulation (each server having their own generator)
      //builds the necessary servers
      for (int i = 0; i < servers.length; i++)
      {  if(i == Constants.SERVER_ENTER) //arrival server
         {  servers[i] = new Server();
         }else
         {  servers[i] = new QueuedServer();
         }
      }

      while(students.size() > 0)
      {  Object o = students.dequeue();
      }

      studentCount = 0;
      time = 0;
      enqueue = 0;
      dequeue = 0;

      statsStart = 0;

      nextServer = 0;

      array = new String[13];

   }

   public void runNextEvent()
   {  if (students.size() < NUM_TIMES)
      {  nextServer = getNextServer();
         time = servers[nextServer].getNextTime();
         updateStats(nextServer);
      }else
      {  enqueue = 0;
         dequeue = 0;
      }
   }

   public String getEnqueue()
   {  return enqueue + "";
   }

   public String getDequeue()
   {  return dequeue + "";
   }

   public int totalSize()
   {  return students.size();
   }

   public void setValues(long seedA, long seedT, long seedS, long seedL, long seedDecision, double  meanA, double meanT, double meanS, double meanL, int P, int numtimes, int startstats)
   //pre: all necessary 5 servers exist and are in the servers array
   //post: the necessary random generators are created for the student class & each server
   {  servers[Constants.SERVER_ENTER].setRandom(seedA, meanA);
      servers[Constants.SERVER_T1].setRandom(seedT, meanT);
      servers[Constants.SERVER_T2].setRandom(seedT, meanT);
      servers[Constants.SERVER_SCHED].setRandom(seedS, meanS);
      servers[Constants.SERVER_OSAP].setRandom(seedL, meanL);
      Constants.setRandom(seedDecision, P);

      NUM_TIMES = numtimes;
      START_STATS = startstats;

      //sets up the arrival server for the first event
      servers[Constants.SERVER_ENTER].setNextEvent(time);
   }


   private int getNextServer()
   //pre: the server array has been created, and at least an entrance server exists
   //post: returns corresponding int value for the server with the next new event
   {
      if (time == 0)
      {  return Constants.SERVER_ENTER;
      }

      //initialize the counters to start at the entrance server
      double nextTime = servers[Constants.SERVER_ENTER].getNextTime();
      int server = Constants.SERVER_ENTER;

      //need to check all the servers
      for(int i = 1; i < servers.length; i++)
      {  //must find the next new event
         if (servers[i].getNextTime() < nextTime && servers[i].getNextTime() >= time && servers[i].getStudent() != null)
         {  nextTime = servers[i].getNextTime();
            server = i;
         }
      }

      return server;
   }

   private void updateStats(int currServer)
   //pre: 0 <= currServer <= servers.length - 1
   //post: according to the current server's event, the current server, and affect server values are updated
   {
      Debug.println("Update stats on server: " + currServer);

      Server server = servers[currServer];
      QueuedServer toServer = null;
      int toS = 5;

      //locates the next server for the student to go to
      if (currServer == Constants.SERVER_ENTER)
      {  //select the less busy tuition server
         if (Constants.toT1())
         {  toServer = (QueuedServer)servers[Constants.SERVER_T1];
            toS = Constants.SERVER_T1;
         }else
         {  toServer = (QueuedServer)servers[Constants.SERVER_T2];
            toS = Constants.SERVER_T2;
         }
         studentCount++;
      }else if(currServer == Constants.SERVER_T1 || currServer == Constants.SERVER_T2)
      {  toServer = (QueuedServer)servers[Constants.SERVER_SCHED];
         toS = Constants.SERVER_SCHED;
      }else if(currServer == Constants.SERVER_SCHED && server.getStudent().toOSAPTable())
      {  toServer = (QueuedServer)servers[Constants.SERVER_OSAP];
         toS = Constants.SERVER_OSAP;
      }

      //determines if the student should be added to the list
      Student student = server.removeStudent();
      dequeue = currServer;

      //determines if the student's statistics should be counted
      if (studentCount >= START_STATS + 1 && currServer == Constants.SERVER_ENTER)
      {  student.recordStats();
         if (studentCount == START_STATS + 1)
         {  statsStart = time;
            for (int i = Constants.SERVER_T1; i < Constants.NUM_SERVERS; i++)
            {  ((QueuedServer)servers[i]).startStats();
            }
         }
      }

      //transfers the student to the next server
      if (toServer != null)
      {  toServer.addEvent(student, time);
         server.setNextEvent(time);
      }else
      {  students.enqueue(student);
         student.quit(time);

         server.setNextEvent(time);
      }
      if (toS == 5)
      {  enqueue = 0;
      }else
      {  enqueue = toS;
      }

   }

   public void calcEvents()
   //pre: the simulation has run as necessary, with all variables initialized
   //post: outputs the gathered statistics to the console
   /**  Stats on - Average total processing time for OSAP students
                 - Average total processing time for non-OSAP students
                 - Average total waiting time overall for OSAP students
                 - Average total waiting time overall for non-OSAP students
                 - Average queue length for each queue server
                 - Average server utilization
   */
   {  Student curr;

      //set to one decimal place
      DecimalFormat df = new DecimalFormat("#.#");

      double totalOSAPProcessing = 0;
      double totalNotOSAPProcessing = 0;
      double totalOSAPQueue = 0;
      double totalNotOSAPQueue = 0;

      int numOSAP = 0;
      int numStudents = 0;

      //process students
      while (students.size() != 0)
      {  curr = (Student)students.dequeue();
         if (curr.hasStats())
         {  if (curr.toOSAPTable()) //the student went to the osap table
            {  totalOSAPProcessing += curr.getTotalTime();
               totalOSAPQueue += curr.getQueueTime();
               numOSAP++;
            }else  //the student did not go to the osap table
            {  totalNotOSAPProcessing += curr.getTotalTime();
               totalNotOSAPQueue += curr.getQueueTime();
            }
            numStudents++;

         }
      }

      if (numOSAP != 0)
      {   array[0] = "" + df.format(totalOSAPProcessing / numOSAP);
          array[1] = "" + df.format(totalOSAPQueue / numOSAP);
      }

      System.out.println("Non-OSAP Students: " + (numStudents - numOSAP));
      if (numOSAP != numStudents)
      {  array[2] = "" + df.format(totalNotOSAPProcessing / (numStudents - numOSAP));
         array[3] = "" + df.format(totalNotOSAPQueue / (numStudents - numOSAP));
      }

      int count = 4;
      if (numStudents != 0 && time != 0)
      {
         //processes each of the 4 different QueuedServers who potentially had line ups
         for (int i = Constants.SERVER_T1; i < Constants.NUM_SERVERS; i++)
         {  QueuedServer server = (QueuedServer)servers[i];
            array[count] = "" + df.format(server.getQueueTime() / (time - statsStart));
            if (server.getStudent() == null)
            {  array[count + 1] = "" + df.format((server.getBusyTime()) / (time - statsStart) * 100);
            }else
            {  array[count + 1] = "" + df.format((server.getBusyTime() - (server.getNextTime() - time)) / (time - statsStart) * 100);
            }
            count = count + 2;

         }

      }
      array[12] = "" + df.format(time);
   }

   public String getosapPro()
   {  return array[0];
   }

   public String getosapQueue()
   {  return array[1];
   }

   public String getnonPro()
   {  return array[2];
   }

   public String getnonQueue()
   {  return array[3];
   }

   public String getlength1()
   {  return array[4];
   }

   public String getutil1()
   {  return array[5];
   }

   public String getlength2()
   {  return array[6];
   }

   public String getutil2()
   {  return array[7];
   }
   public String getlength3()
   {  return array[8];
   }

   public String getutil3()
   {  return array[9];
   }
   public String getlength4()
   {  return array[10];
   }

   public String getutil4()
   {  return array[11];
   }

   public String gettotalTime()
   {  return array[12];
   }
}