/*
 *  Serial Discrete Event Simulation
 *  Written by A Sahu <asahu@iitg.ernet.in>
 *  Date and Time: 4.00 PM 03 Nov 2013
 *  AutoGenerated by Eclipse IDE for Java Developers
 *
 *  We have used a serial priority queue of size N and have one operation
 *  repeated F time F >> N. The operation is reduce prioprity of
 *  min element (top/front element) which means get extract-min 
 *  and re-insert with lower priority (higher time).    
 * 	//EventObj=PQ.poll(); ReducePriory(EventObj); PQ.add(EventObj);
 *  
 *  Design Challenge:One may design a very good PQ to reduce asymtotic time 
 *  or amortized time of this highly frequent reduce prioprity operation. 
 *  
 */
import java.util.Vector;
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Queue;

class Agent{
	public Vector<Integer> MessageBox;
	public Agent(){ MessageBox= new Vector(100); }
	public	void Think(){MessageBox.clear();}
	public 	void Send(Agent A, int Data){A.AddMessage(Data);}
	public 	void AddMessage(int Data){MessageBox.add(Data);}
}
class Event {
	public int AgentNum, TypeOfEvent, Receiver, Data, FiringTime;
	public	Event(){}
	public	Event(int AgentNumI, int typeI, int ReceI, int DataI, int FiringTimeI){
		AgentNum=AgentNumI; FiringTime=FiringTimeI;
		TypeOfEvent=typeI; Receiver=ReceI; Data=DataI;
	} 
}

class PDES {
	// PDES Data
	public int CurrentTime;
	public int TotalAgent;
	public int MaxSimultionTime;
	public int THINK_EVENT,THINK_EVENT_EXECUTED;
	public int SENT_EVENT, SENT_EVENT_EXECUTED;
	public double Prob;
	public int MaxThinkTime,SENTTime;
	public Agent[] AA; //Agent Array
	public Queue<Event> PQ; // Priority Queue of Event

	// PDES Methods
	public PDES(){}		
	public PDES(int TA, int MAXTime){
		TotalAgent=TA; 
		MaxSimultionTime=MAXTime;
		AA= new Agent[TotalAgent];
		for(int i=0;i<TotalAgent;i++) AA[i]= new Agent();
	}		
	public void Initialize(){
		THINK_EVENT=THINK_EVENT_EXECUTED=SENT_EVENT=SENT_EVENT_EXECUTED=0;
		CurrentTime=0;
		Prob=0.3; // One can change this to required
		MaxThinkTime=100; // One can change this to required
		SENTTime =10; // One can change this to required
		PQ = new PriorityQueue ( TotalAgent, new Comparator<Event>(){ 
				public int compare(Event c1, Event c2) {
				return (int) (c1.FiringTime - c2.FiringTime);
				} }  );
		for(int i=0;i<TotalAgent;i++)  
			AddEvent(i, 0,0);
	}
	public void AddEvent(int i, int T, int READD){
		int ThinkTime, FTime, TypeE;
		int SENT=1,THINK=0;
		int Ts=SENTTime; 
		double p, a, b; 
		int RandomReciever=(int)(Math.random()*TotalAgent);
		int RandomData=(int)(Math.random()*100.0);
		int RandomTime=(int)(Math.random()*(double)(MaxThinkTime));

		p=Prob;	a=Math.random()*100.0;  b = p*100.0;

		if (a<b) { 
			TypeE=SENT; SENT_EVENT++; FTime=T+Ts; 
		} 
		else {	
			TypeE=THINK; THINK_EVENT++;FTime=T+RandomTime; 	
		}
		if (READD==0){ // Initial Addition to PQ
			Event EventObj=new Event(i,TypeE,RandomReciever,RandomData,FTime);
			PQ.add(EventObj);
		}else{  // When executing the event
			Event EventObj=PQ.poll(); 
			EventObj.TypeOfEvent=TypeE; EventObj.Receiver=RandomReciever;
			EventObj.Data=RandomData;EventObj.FiringTime=FTime;
			PQ.add(EventObj); // Every ExtractMin/poll is followed by a ADD with reduced Priority 
		}
	}
	public void ExecuteEvent(Event E){
		int THINK=0;	
		if ( (E.AgentNum>TotalAgent) || (E.Receiver>TotalAgent) ) return;
		if (E.TypeOfEvent==THINK) { 
			AA[E.AgentNum].Think();
			THINK_EVENT_EXECUTED++;
		}else{ // Event is type SENT
			AA[E.Receiver].AddMessage(E.Data);
			SENT_EVENT_EXECUTED++;
		}

	}
	public void Work()  {
		Event E;
		int EventAtCt=0;
		while(true){
			if (CurrentTime > MaxSimultionTime ) break;
			E = PQ.peek(); //Assume lots of events are in PQ with fire time CurrTime+1
			if(E ==null) continue;		
			if(E.FiringTime<=CurrentTime) {
				ExecuteEvent(E); AddEvent(E.AgentNum,CurrentTime,1);EventAtCt++;
			}
			else { 	CurrentTime++;	EventAtCt=0;}
		}//end while
	}
	public void PrintReport(){
		System.out.println("***********************************************************************");
		System.out.println("Simultion Statistics ");
		System.out.println("***********************************************************************");
		System.out.println("Max Simultion Time:=\t"+MaxSimultionTime);
		System.out.println("Total Agents:=\t"+TotalAgent);
		System.out.println("Prob of Send:=\t"+Prob);
		System.out.println("Number of THINK Event generated:=\t"+THINK_EVENT);
		System.out.println("Number of THINK Event executed:=\t"+THINK_EVENT_EXECUTED);
		System.out.println("Number of SENT Event generated:=\t"+SENT_EVENT);
		System.out.println("Number of SENT Event executed:=\t"+SENT_EVENT_EXECUTED);
		System.out.println("Total Number of Decrease Priority Operation Executed :=\t"+(THINK_EVENT_EXECUTED+SENT_EVENT_EXECUTED));
		System.out.println("***********************************************************************");
	}
}
public class SerialDESTest {
	//This program takes around 50s to run
	public static void main(String args[]){
		int NumAgent, MaxSimTime;
		NumAgent=1000000; MaxSimTime=1000;//You need to run for 1M agent NumAgent=1000000
		PDES  P=new PDES(NumAgent, MaxSimTime);
		P.Initialize();
		System.out.println("Initialized...\n");
		long startTime = System.currentTimeMillis();	
		P.Work();
		/* In parallel version P.work() will be executed by all threads.
		   Instead of using a serial PQ, one need to use thread-safe
		   high performance queue (CoarseGrain/finegrain/skiplist based CPQ).	 
		   */
		long stopTime = System.currentTimeMillis();
		P.PrintReport();
		long elapsedTime = stopTime - startTime;
		System.out.println("Simulation/Execution Time on Machine:"+elapsedTime+" ms");
		System.out.println("***********************************************************************");
	}
}