//////////////////////////////////////////////////////
//													//
//	Incremental Clock Syncronization.				//
//	236503(20)	Summer 2001							//
//	Advanced Programming Project.					//
//	Technion. Computer Science Department.			//
//													//
//	Written by:		Reitman Anna	<s0anna0r@t2>	//
//					Fidelman Greg	<sgregf@t2>		//
//	Supervisor:		Hagit Attya		<hagit@cs>		//
//					Saar Pilosof	<psaar@cs>		//
//													//
//////////////////////////////////////////////////////
// ProcessHolder.cpp
#include "stdAfx.h"
#include <iostream>
#include <limits>
#include <math.h>

#include "ProcessHolder.h"
#include "Process.h"

ProcessHolder::ProcessHolder(	long nProcNum,
								long nMinClock,
								long nMaxClock,
								long nPercentCorrectProcs,
								long msgPerSlot,
								SendMsgRule msgRule	):
	m_nProcNum(nProcNum),m_nMinClock(nMinClock),m_nMaxClock(nMaxClock),
	m_nPercentCorrectProc(nPercentCorrectProcs),
	m_nMsgPerSlot(msgPerSlot),m_eMsgRule(msgRule)
{
	
	if( ( m_nProcNum < 2 ) || ( m_nMinClock < 0 ) || (m_nMaxClock < m_nMinClock ) ||
		( m_nPercentCorrectProc < 0 ) || ( m_nPercentCorrectProc > 100 ) ||
		( m_nMsgPerSlot < 1 ) )
	{
		std::cout << "ProcessHolder: Input is not correct!\n";
		exit(1);
	}
	if( !initProcessVector_() ){
		std::cout << "ProcessHolder: Cannot initialize processes\n";
		exit(1);
	}

}


ProcessHolder::ProcessHolder(	long nProcNum,
								long nClocksValue,
								long nNewProcClock,
								long msgPerSlot,
								SendMsgRule msgRule	):
	m_nProcNum(nProcNum),m_nClocksValue(nClocksValue),
	m_nNewProcClock(nNewProcClock),m_nMsgPerSlot(msgPerSlot),m_eMsgRule(msgRule)
{

	if( ( m_nProcNum < 2 ) || ( m_nClocksValue < 0 ) || ( m_nNewProcClock < 0 ) ||
		( m_nMsgPerSlot < 1 ) )
	{
		std::cout << "ProcessHolder: Input is not correct!\n";
		exit(1);
	}
	if( !initNewProcVector_() ){
		std::cout << "ProcessHolder: Cannot initialize processes\n";
		exit(1);
	}
}


ProcessHolder::~ProcessHolder()
{
	for( ProcessVector::iterator iterProc = m_ProcVector.begin();
		 iterProc != m_ProcVector.end(); iterProc++ )
	{
		delete (*iterProc);
	}
	
}

bool ProcessHolder::initNewProcVector_()
{
	m_ProcVector.reserve(m_nProcNum);

	// the new process is always created first
	Process* pProc = new Process(0,m_nNewProcClock);
	m_ProcVector[0] = pProc;
//	DBG << "nProc = "<< 0 <<" nInitClock = "<<m_nNewProcClock<<std::endl;

	for( long nProc = 1; nProc < m_nProcNum; nProc++ ){
//		DBG << "nProc = "<<nProc<<" nInitClock = "<<m_nClocksValue<<std::endl;
		pProc = new Process(nProc,m_nClocksValue);
		m_ProcVector[nProc] = pProc;
	}

	return true;
}



bool ProcessHolder::initProcessVector_()
{

	long CorrectValue = (m_nMaxClock + m_nMinClock) / 2;
	//always a first part of the processes is a correct part
	long nOfCorrectProcs = ceil(m_nProcNum * m_nPercentCorrectProc / 100.0);

	m_ProcVector.reserve(m_nProcNum);
	for( long nProc = 0; nProc < m_nProcNum; nProc++ ){
		srand(nProc*17);
		long  nInitClock = ( nProc<nOfCorrectProcs ? CorrectValue :
			m_nMinClock + rand()%(m_nMaxClock - m_nMinClock) );
		if( nProc>=nOfCorrectProcs ){
			while( nInitClock == CorrectValue )
				nInitClock = m_nMinClock + rand()%(m_nMaxClock - m_nMinClock);
		}
//		DBG << "nProc = "<<nProc<<" nInitClock = "<<nInitClock<<std::endl;

		Process* pProc = new Process(nProc,nInitClock);
		m_ProcVector[nProc] = pProc;
	}
//	for( nProc = 0; nProc < m_nProcNum; nProc++ ){
//		DBG << "m_ProcVector["<<nProc<<"].HagitClock="<<(*m_ProcVector[nProc]).Hagit.m_Clock<<std::endl;
//	}
	return true;
}


//used only by Hagit algorithm
bool ProcessHolder::sendMessage(long fromID,long msg)
{
 long toProcID = fromID;
 MessagePair msgPair(fromID,msg);

	switch( m_eMsgRule ){
	case RANDOM:
		{
			for( long nMsg = 1; nMsg <= m_nMsgPerSlot; ++nMsg ){
				srand(fromID*nMsg*17);
				toProcID = rand()%m_nProcNum;
				if( toProcID == fromID ){
					toProcID = ( toProcID == (m_nProcNum-1) ? 0 : toProcID+1 );
				}
				(m_ProcVector[toProcID]->m_Hagit).m_NextMsgBuff->push_back(msgPair);
			}
		}
		break;
	case SEQUENTIAL:
		{
			for( long nMsg = 0; nMsg < m_nMsgPerSlot; ++nMsg ){
				toProcID = ( toProcID == (m_nProcNum-1) ? 0 : toProcID+1 );
				if( toProcID == fromID ) continue;
				(m_ProcVector[toProcID]->m_Hagit).m_NextMsgBuff->push_back(msgPair);
			}
		}
		break;
	}
	return true;
}


//used by ST algorithm only
bool ProcessHolder::broadcastMessage(long fromID,long msg)
{
 MessagePair msgPair(fromID,msg);

	//iterate over all processes and send msg to each of them
	for( long nProc = 0; nProc < m_nProcNum; nProc++ ){
		//if( nProc==fromID ) continue;
		(m_ProcVector[nProc]->m_ST).m_NextMsgBuff->push_back(msgPair);
	}
	return true;
}


void ProcessHolder::incClocks()
{
	for( long nProc = 0; nProc < m_nProcNum; ++nProc ){
		(m_ProcVector[nProc]->m_Hagit).m_Clock++;
		(m_ProcVector[nProc]->m_ST).m_Clock++;

		MessageBufferList*	tmpBuff = (m_ProcVector[nProc]->m_Hagit).m_CurrMsgBuff;
		(m_ProcVector[nProc]->m_Hagit).m_CurrMsgBuff = (m_ProcVector[nProc]->m_Hagit).m_NextMsgBuff;
		(m_ProcVector[nProc]->m_Hagit).m_NextMsgBuff = tmpBuff;
	
		tmpBuff = (m_ProcVector[nProc]->m_ST).m_CurrMsgBuff;
		(m_ProcVector[nProc]->m_ST).m_CurrMsgBuff = (m_ProcVector[nProc]->m_ST).m_NextMsgBuff;
		(m_ProcVector[nProc]->m_ST).m_NextMsgBuff = tmpBuff;
	}
}

// return pair<HagitGap,STGap>
std::pair<long,long> ProcessHolder::getGap() const
{
	long minHagitClock = LONG_MAX;
	long maxHagitClock = LONG_MIN;
	long minSTClock = LONG_MAX;
	long maxSTClock = LONG_MIN;

	//iterate over processes and collect the clock value of 2 algorithms
	for( long nProc = 0; nProc < m_nProcNum; ++nProc ){
		long clock = (m_ProcVector[nProc]->m_Hagit).m_Clock;
		if( clock > maxHagitClock ) 
			maxHagitClock = clock;
		if( clock < minHagitClock )
			minHagitClock = clock;

		clock = (m_ProcVector[nProc]->m_ST).m_Clock;
		if( clock > maxSTClock )
			maxSTClock  = clock;
		if( clock < minSTClock )
			minSTClock = clock;

	}
	std::pair<long,long> gap(maxHagitClock-minHagitClock,maxSTClock-minSTClock);
	return gap;
}