import java.io.*;
import java.util.*;
import java.lang.*;
import java.util.Random;

/**This class is the java-version of the Phold.c from GTW. It is used for testing the sim kernel. 
  *The original Vaucher Duval hold mode was introduced solely to approximate a
  *simulation application interaction with its event calendar.
  *
  *<p> An application is assumed to operate with a fixed number of initial events in the calendar. 
  *In operation, it deletes the earliest event from the calendar, synchronizes the simulation clock with
  *this event scheduled time of occurrence, processes the event, and then inserts a
  *newly scheduled event into the calendar. 
  *
  *<p>begin
  * <ul>
  *   <li>initialize event calendar with 1000 events
  *   <li>done =false; hold_count=0;
  *   <li>begin titak_time measure
  *   <li>while (not doen) do {
  *     <ul>
  *        <li>Delete highest priority event from calendar
  *        <li>Synchronize clock with this event's time of occurence
  *        <li>Define a scheduled time to be clock time plus a random variate from a 
  *            given scheduling distributioin
  *        <li>Encode scheduled time in new_event;
  *        <li>Insert new_event in calendar;
  *        <li>hold_count:=hold_count + 1
  *        <li>if(hold_count=n) then done:=true}
  *     </ul >
  *   <li>End total_time measure
  *   <li>hold_time=hold_time/n;
  *   <li>end hold algorithm
  * </ul>     
  *@author Yin Xiong
  *@version 1.0 (09/2006)
  */
  

public class Phold extends LogicalProcess{

/**class member for keeping track of how many messages have been sent.*/
int count;

/**message population */
int MsgPop;

/**the number of LPs*/
int numLPs;

/**the time increment for messages sent by this LP; the message will be sent at currentTime+timeIncrement*/
int timeIncrement;

/**random number generator*/
Random random;

/**PEid and LPid of this LP, for debugging only*/
String alias;

/**Constructs a new Phold instance.*/
public Phold()
{
   super();
   MsgPop=6;
   count=0;  
   timeIncrement=0;
   numLPs=2;
   random=new Random();
}


/**Initiates the LP and generates the initial message. It's the counterpart of "IProc"
  *in GTW.
  */
public boolean appInitializeLP()
{
   alias=PEid+"-"+LPid;
   System.out.println(alias + " initializing...\n");
   int destLP;

  //translated from GTW phold.c
  //send initial messages
  count=0;

  for(int i=LPid;i<MsgPop;i=i+numLPs){
   destLP=random.nextInt(numLPs);
   //System.out.println(alias + " get dest lp " + destLP);

   //get timestamp
/*   double u=random.nextDouble();
   double lambda=1;
   double ts=nextExponential(u,lambda);
   timeIncrement=(int)(ts*10);
   System.out.println(alias + " get time increment " + timeIncrement);
*/

   timeIncrement=1;
   //content is the number of holds
   String content=String.valueOf(count);
   sendSimMessage(content, timeIncrement, destLP);
   System.out.println(alias + " sending initial msg to " + destLP);
   count++;
   tSleep(500);

  }//end for

  return true;
}

void tSleep(int tim)
{
   try{
     Thread t=Thread.currentThread();
     t.sleep(tim);
   }
   catch(Exception e){
     e.printStackTrace();
  }
}//end tSleep

/**Handles events for Phold.
  *It is the counterpart of "Proc" in GTW.
  *@param content an Object representing the content of the message to be sent
  *@param sender String the application-assigned name of the sender of this message
  */
public void appRunLP(Object content, String sender)
{
  // System.out.println(alias+ " running...\n");

  count=Integer.parseInt((String)content);
  if(count<MsgPop){
  int destLP;

  /*translated from GTW phol.c: bounce message*/
   /*  double ts=nextExponential(random.nextDouble(), 1.0);
     timeIncrement=(int)(ts*10);
   */
     timeIncrement=1;  
     destLP=random.nextInt(numLPs);
     count++;
     System.out.println("count: " + count);

     content=String.valueOf(count);
     System.out.println(alias + " sending msg to " + destLP);
     sendSimMessage(content, timeIncrement, destLP);
 }//if count<msgPop

else{
    setEndOfSimFlag();
 }//end if not end of sim message

}

/**Terminates LP and displays simulation statistics. It is optionally called at the end of the
  *simulation. It is the counterpart of "FProc" in GTW.
  */
public void appFinalizeLP()
{
   System.out.println(alias + " is finalizing...\n");

}

/**Returns a random number from exponential distributioin
  *@param u double the random number from a uniform distribution
  *@param lambda double the arrival rate
  */
double nextExponential(double u, double lambda)
{
   double d=Math.log(1-u)*(-1/lambda);
   return d;
}   


/**Implements abstract method to save LP state*/
public LogicalProcess appSavingLPState()
{
   Phold p=new Phold();
   p.myname=myname;
   p.count=count;
   return (LogicalProcess)p;
}

/**Implements abstract method to set the state of this LP to the state of a specified Phold*/
public void appSetLPState(LogicalProcess lp)
{
   Phold p=(Phold)lp;
   count=p.count;
   myname=p.myname;
   //System.out.println("in ping rollbacl, count: " + count);
}//end setState


/**Sets application-specific configuration data.
 * @param cdata String representing configuration data.
 */
public void appSetConfigData(String cdata)
{
}

/**Implements abstract method for dispaly purpose only*/
public String appToString()
{
    return(myname+ " " + count);
}


/*****************to be implemented*****************************/


/**Method to get the value of a given application-level monitorable variable.
 * @since 1.5
 * @param name The name of the variable to monitor
 * @return The value of the variable in question
 */
public String appGetState(String name)
{
   return "Not yet implemented";
 
}


/**Method to set the value of a given application-level monitorable variable.
 * @since 1.5
 * @param name The name of the variable to steer
 * @param val The value to assign to the variable
 * @return Null if the steering was successful, else a String describing the
 * error that occurred.
 */
public String appSetState(String name, String val)                                                                     
{
   return "under programming";
}

   
/** Returns a List of Strings describing all application-specific steerable
 * parameters of this LP, each in the form "paramName, paramType".
 * @since 1.5
 * @return List listing all application-specific steerable parameters.
 */
public  List<String> appGetSteerable()
{
   return null;
}
 

/**Returns a List of Strings describing all application-specific monitorable
 * parameters of this LP, each in the form "paramName, paramType".
 * @since 1.5
 * @return List listing all application-specific montiorable parameters.
 */
public List<String> appGetMonitorable()                                                                                
{
   return null;
}


}//end Ping