/*******************************************************************
*
*  DESCRIPTION: class ProcessorAdmin
*
*  AUTHOR: Amir Barylko & Jorge Beyoglonian 
*
*  EMAIL: mailto://amir@dc.uba.ar
*         mailto://jbeyoglo@dc.uba.ar
*
*  DATE: 27/6/1998
*
*******************************************************************/

/** include files **/
#include "procadm.h"          // header
#include "simulat.h"          // class Simulator
#include "coordin.h"
#include "mcoordin.h"		
#include "scoordin.h"
#include "strutil.h"          // lowerCase
#include "root.h"             // class Root
#include "coorcell.h"         // CellCoordinator
#include "flatcellcoor.h"         // FlatCoordinator
#include "flatcoup.h"         // FlatCoupledCell
#include "atomic.h"

/** public data **/
const ProcId ProcessorAdmin::rootId( 0 ) ;

/** private data **/
ProcessorAdmin *SingleProcessorAdmin::instance( NULL ) ;

/** public functions **/
/*******************************************************************
* Function Name: ProcessorAdmin
********************************************************************/
ProcessorAdmin::ProcessorAdmin() 
: procIdCount( ProcessorAdmin::rootId + 1 )
{}

/*******************************************************************
* Function Name: ~ProcessorAdmin()
* Description: destroys all the alive processors
********************************************************************/
ProcessorAdmin::~ProcessorAdmin()
{
	for ( ProcessorDB::iterator cursor = procDB.begin(); cursor != procDB.end(); cursor++ )
		delete cursor->second;
}

/*******************************************************************
* Function Name: generateProcessor
********************************************************************/
Processor &ProcessorAdmin::generateProcessor( Atomic *atomic,const ProcId id )
{
	Simulator *sim = new Simulator( atomic );
	add2DB( sim, id );
//	add2DB( sim, newId() );
	
	atomic->processor( (Processor*) sim );
	
	return *sim;
}

/*******************************************************************
* Function Name: generateProcessor
********************************************************************/
Processor &ProcessorAdmin::generateProcessor( Coupled *coupled , const ProcId id)
{
	Coordinator *coord;
	if ( coupled->isLocalMaster() ) 
	{
		coord = new MCoordinator( coupled );
//		cout << "created MCoordinator for " << coupled->description() << endl;
	}
	else 
	{
		coord = new SCoordinator( coupled );
//		cout << "created SCoordinator for " << coupled->description() << endl;	
	}
	add2DB( coord, id );
//	add2DB( coord, newId() );
	
	coupled->processor(coord);
	
	return *coord;
}

/*******************************************************************
* Function Name: generateProcessor
********************************************************************/
Processor &ProcessorAdmin::generateProcessor( CoupledCell *coupled,const ProcId id )
{
//	Coordinator *coord = new CellCoordinator( coupled ) ;

	Coordinator *coord ;

	if ( coupled->isLocalMaster() )
	{
		coord = new MCoordinator( coupled );
//		cout << "generated MCoordinator for " << coupled->description() << endl;
	}	
	else
	{
		coord = new SCoordinator( coupled );
//		cout << "generated SCoordinator for " << coupled->description() << endl;	
	}
	add2DB( coord, id);
//	add2DB( coord, newId() ) ;
	
	coupled->processor(coord);
	
	return *coord ;
} 

/*******************************************************************
* Function Name: generateProcessor
********************************************************************/
Processor &ProcessorAdmin::generateProcessor( FlatCoupledCell *coupled,const ProcId id )
{
	Coordinator *coord = new FlatCellCoordinator( coupled ) ;
//	add2DB( coord, newId() ) ;
	add2DB( coord , id );
	
	coupled->processor(coord);
	
	return *coord ;
} 

/*******************************************************************
* Function Name: generateRoot
********************************************************************/
Processor &ProcessorAdmin::generateRoot()
{
	Root *root = new Root( ProcessorAdmin::rootId ) ;
	add2DB( root, ProcessorAdmin::rootId ) ;
	return *root ;
}

/*******************************************************************
* Function Name: processor
********************************************************************/
Processor &ProcessorAdmin::processor( const ProcId &id )
{
	ProcessorDB::iterator cursor( procDB.find( id ) );

	if( cursor == procDB.end() )
	{
		InvalidProcessorIdException e;
		e.addText( string( "The processor id " ) + id + " is invalid!" ) ;
		MTHROW( e ) ;
	}
	MASSERT( cursor->second );
	return *( cursor->second );
}

/*******************************************************************
* Function Name: processor
********************************************************************/
Processor &ProcessorAdmin::processor( const string &name )
{
	string lower( lowerCase( name ) ) ;

	ProcessorDB::iterator cursor( procDB.begin() );

	while( cursor != procDB.end() && cursor->second->description() != lower )
		cursor ++ ;

	if( cursor == procDB.end() )
	{
		InvalidProcessorIdException e ;
		e.addText( string( "The processor " ) + lowerCase( name ) + " is invalid!" );
		MTHROW( e ) ;
	}
	return *( cursor->second );
}

/*******************************************************************
* Function Name: add2DB
********************************************************************/
ProcessorAdmin &ProcessorAdmin::add2DB( Processor *newProc, const ProcId &newId )
{
//	cout << "generated processor " << newProc->description() << endl;
	newProc->id( newId );
	procDB[ newId ] = newProc;
	return *this;
}

void ProcessorAdmin::model(const ProcId &pid, Model *model)
{
	procModelDB[pid] = model;	
}

Model &ProcessorAdmin::model(const ProcId &pid) const
{
	ProcessorModelDB::const_iterator cursor;
	
	cursor = procModelDB.find(pid);
	
	if(cursor != procModelDB.end())
		return *(cursor->second);
	
}