#ifdef MPI

//#include <iostream.h>
//#include <iomanip.h>
#include <iostream>
#include <iomanip>
#include <my_math.h>
//#include <stdlib.h>
#include <string.h>
#include "SA_EasyScheduler.h"


SA_EasyScheduler::SA_EasyScheduler(): 
	SA_ClusteringScheduler(),
	CoolingRatio(0.9),
	subchainfactor(1.0),
	SubChainReduct(true),
	MinAccRatio(LOWER_ACCEPTANCE_RATIO),
	MaxChainLength(0),
	MaxChainLength0(0),
	frozen_count(0),
	frozen_limit(5),
	pos(0),full(0),FrozenSum(0),Mean(0),
	saeasyoutput("SA_EasyScheduler","SA_Output.rsc")
{//debug(SA_EasyScheduler::Konstruktor  ,myrank);
	saeasyoutput.EnableLevelNumbers(false);
	saeasyoutput.EnableIdentifier(true);
	saeasyoutput.SetOutputLevel(10);
	
	saeasyoutput.AddVariable(1,SA_FLOAT, &CoolingRatio);
	saeasyoutput.AddVariable(2,SA_FLOAT, &MinAccRatio);
	saeasyoutput.AddVariable(3,SA_FLOAT, &subchainfactor);
	saeasyoutput.AddVariable(4,SA_BYTE, &SubChainReduct);
	saeasyoutput.AddVariable(5,SA_LONG, &MaxChainLength);
	saeasyoutput.AddVariable(6,SA_LONG, &MaxChainLength0);
	saeasyoutput.AddVariable(7,SA_LONG, &frozen_count);
	saeasyoutput.AddVariable(8,SA_LONG, &frozen_limit);
	// strcpy(strictshortstr,"strict    ");		
	saeasyoutput.AddVariable(9,SA_STRING, SubChainReductStr);

	saeasyoutput.SetPreviousOutput(SA_ClusteringScheduler::GetSchedulerOutput());
		
	LastSolutions = new float[frozen_limit];
	for (int i=0; i < frozen_limit; i++) LastSolutions[i] = 0;
}

// \******************************************************
// Destruktor
// \******************************************************
SA_EasyScheduler::~SA_EasyScheduler()
{//debug(SA_EasyScheduler::Destruktor  , myrank);

	delete [] LastSolutions;	

}

SA_Output * SA_EasyScheduler::GetSchedulerOutput() {
  return(&saeasyoutput);
}
// \******************************************************
// Methode ReadConfig - Liest die Konfigurations-
// daten ( geklammert mit '{' '}'  ) aus dem istream
// \******************************************************
int SA_EasyScheduler::ReadConfig(std::istream & config)
{//debug(SA_EasyScheduler::ReadConfig  , myrank);

	char text[BUFLEN];
	config >> text;
	if ( strcmp(text,"{") != 0)
	{
		std::cout << "In SA_EasyScheduler::ReadConfig: config file section does not begin with {!\n";
		return FALSE;
	}
	
	while (config >> text && ( strcmp(text,"}") != 0 ))
	{
		if (strcmp(text, "SA_Scheduler") == 0)
		{
			if ( ! SA_Scheduler::ReadConfig(config) )
			{
				std::cout <<"ReadConfing for Scheduler failed!\n";
				return 0;
			}
		}

	  else if (strcmp(text, "coolingratio") == 0)
		{
			config >> text;
			SetCoolingRatio( atof(text) );
		}

	  else if (strcmp(text, "frozenlimit") == 0)
		{
			config >> text;
			SetFrozenLimit( atol(text) );
		}
	  else if (strcmp(text, "minaccratio") == 0)
		{
			config >> text;
			MinAccRatio = atof(text);
			if ( MinAccRatio < 0 || MinAccRatio >= 1)
			{
				std::cout <<"In SA_EasyScheduler::ReadConfig: bad value "<< MinAccRatio<<" for minaccratio specified!\n"; 
				MinAccRatio = -1;
			}
		}
	  else if (strcmp(text, "subchainlength") == 0)
		{
			config >> text;
			MaxChainLength = MaxChainLength0 = atol(text);
		}
	  else if (strcmp(text, "subchainfactor") == 0)
		{
		  config >> text;
		  subchainfactor = atof(text);
		}
	  else if (strcmp(text, "subchainreduction") == 0)
		{
		  config >> text;
		  std::cerr << "DBG: ==================> " << text << std::endl;
		  if (strcmp(text, "linear") == 0 || strcmp(text, "sqrt") == 0 || strcmp(text,"none")) {
			 strcpy(SubChainReductStr,text);
			 SubChainReduct = LINEAR;
			 if (strcmp(text, "sqrt") == 0) {
			   SubChainReduct = SQUAREROOT;			 
			 } else if (strcmp(text,"none")) {
			   SubChainReduct = NONE;
			 }
		  } else {
			  strcpy(SubChainReductStr,"linear");
			  SubChainReduct = LINEAR;
			  std::cout <<"In SA_EasyScheduler::ReadConfig: bad value "<< text<<" for subchainlength specified! Leaving default \"linear\"\n"; 
		  } 				  
		}
	  else if (strcmp(text, "verboselevel") == 0)
		{
		  config >> text;
		  saeasyoutput.SetOutputLevel(atoi(text));
		}
	  else
		{
			std::cout <<"In SA_EasyScheduler::ReadConfig: unrecognized keyword \""<<text<<"\""<<std::endl;
		}
	}

	return (strcmp(text,"}") == 0 );
}

void SA_EasyScheduler::SetFrozenLimit(unsigned long lim)
{//debug(SA_EasyScheduler::SetFrozenLimit, myrank);

	if (lim == frozen_limit)
		return;
	frozen_limit = lim;
	if(frozen_limit == 0 )
		return;
	delete [] LastSolutions;
	LastSolutions = new float[frozen_limit];
	for (int i=0; i < frozen_limit; i++) LastSolutions[i] = 0;	
}


// \******************************************************
// Methode ShowConfig - Gibt die aktuelle Parameter
// aus (nur zur Kontrolle).
// \******************************************************
void SA_EasyScheduler::ShowConfig(std::ostream & out)
{//debug(SA_EasyScheduler::ShowConfig  , myrank);

	out << "SA_EasyScheduler Konfiguration:" << std::endl;

	SA_Scheduler::ShowConfig(out);
	
	out	<< "\tcooling factor:       " << CoolingRatio << std::endl
		<< "\tstart temperature:    " << StartT << std::endl 
		<< "\tmax subchain length:  " << MaxChainLength << std::endl
		<< "\tMinAcceptRatio:       " << MinAccRatio <<std::endl
		<< "\tFrozenlimit:          " << frozen_limit <<std::endl
		<< "\tsubchain shortening:  " << *SubChainReductStr <<std::endl;
}


// \******************************************************
// Methode Output - Schreibt die Ergebnisse in die
// Logdatei.
// \******************************************************
void SA_EasyScheduler::CreateLog(std::ostream &out, MPI_Comm comm)
{//debug(SA_EasyScheduler::OutputStatistics  , myrank);

	int me,nproc;
	int flag;
	MPI_Initialized(&flag);
	if (flag)
	{
		MPI_Comm_rank(comm,&me);

		if ( me == 0 )
		{
			out << "Sched=Easy";	
		}

		SA_ParScheduler::CreateLog(out,comm);
		if ( me == 0 )
		{
			out	<<" MinAc="<<MinAccRatio<<" FL=" <<frozen_limit << " C=" << CoolingRatio <<" LN="<<MaxChainLength0 ;
			out <<" Short="<< *SubChainReductStr;

		}
	}
	else
	{
		out << "Sched=Easy";
		SA_ParScheduler::CreateLog(out,comm);
		out	<<" MinAc="<<MinAccRatio<<" FL=" <<frozen_limit << " C=" << CoolingRatio <<" LN="<<MaxChainLength0 ;
		out <<" Short="<< *SubChainReductStr;
	}
}


// \******************************************************
// Methode UpdateTemperatureFixed - Aktualisiert die
// Temperatur mit einem konstanten Faktor.
// \******************************************************
void SA_EasyScheduler::UpdateTemperature()
{//debug(SA_EasyScheduler::UpdateTemperature, myrank);

	if( MinAccRatio < 0 )	// if MinAccRatio wasn't set in config file
	{
		Enqueue();

		if ( FABS(E - Mean)/Mean < EPSILON) 
			frozen_count++; 
		else
			frozen_count=0;
	}
	else
	{
		if ( GetMeanAcceptRatio() < MinAccRatio )
{
			frozen_count++; 
}
		else
			frozen_count=0;
	}

	SetNewT( T*CoolingRatio );
}

// \******************************************************
// Methode Equilibrium - Entscheidet, ob im gegebenen
// Schleifendurchlauf das Gleichgewicht erreicht wurde.
// \******************************************************
int SA_EasyScheduler::Equilibrium()
{//debug(SA_EasyScheduler::Equilibrium, myrank);
  return( TimeExceeded() || n_iter > MaxChainLength );
//	||	   (( n_accepts != 0) && (( EPSILON + (float)n_accepts/n_iter ) < LOWER_ACCEPTANCE_RATIO) ));
}

// \******************************************************
// Methode Enqueue - Speichert die letzten frozen_limit
// Kostenwerte.
// \******************************************************
void SA_EasyScheduler::Enqueue()
{//debug(SA_EasyScheduler::Enqueue, myrank);

	FrozenSum += E - LastSolutions[pos];
	LastSolutions[pos] = E;
	pos = (pos+1)%frozen_limit;
	if ( pos == 0)
		full = TRUE;
		
	Mean = FrozenSum / (full?frozen_limit:pos);
}


// \******************************************************
// Methode Frozen - Entscheidet, ob das System
// zum Stillstand gekommen ist.
// \******************************************************
int SA_EasyScheduler::Frozen()
{//debug(SA_EasyScheduler::Frozen  , Getmyrank());
	
	return (TimeExceeded() || frozen_count >= frozen_limit);
}


// die Bestimmung der Startwerte 
void SA_EasyScheduler::WarmingUp(SA_Problem & P, SA_Solution &s, SA_Solution &b, MPI_Comm comm)
{//debug(SA_EasyScheduler::WarmingUp  , myrank);

	if ( MaxChainLength == 0)	// if subchainlength wasn't set in .cfg-file
	{
		MaxChainLength = MaxChainLength0 = (unsigned long)ceil(P.GetLocalN());
		int flag;
// if there are many procs, set to the mean (necessary due to the fact LocalN is an ESTIMATION)
		MPI_Initialized(&flag);
		if(flag)
		{
			MPI_Allreduce(&MaxChainLength,&MaxChainLength0,1,MPI_UNSIGNED_LONG,MPI_SUM,comm);
			int n;
			MPI_Comm_size(comm,&n);
			MaxChainLength = MaxChainLength0 = MaxChainLength0 / n;
		}

	}
	
// use the subchainfactor (def. is 1)
	MaxChainLength = MaxChainLength0 = (unsigned long)ceil(MaxChainLength*subchainfactor);
	
	if( AartsRecommended())	// if StartT wasn't set in .cfg-file 
	{
		SetStartT( AartsWarmingUp(P,s,b,MaxChainLength,comm));
	}
}


// die Anzahl der Cluster dem Scheduler mitteilen:
//  die Laenge der Kette an den einzelnen Prozessoren wird angepasst 
void SA_EasyScheduler::SetClusterNumber(unsigned long n_clu, unsigned long clu_size)
{
	n_cluster = n_clu;
	cluster_size = clu_size;
	if(SubChainReduct == LINEAR) {
		MaxChainLength = MaxChainLength0/n_clu;
	} else if (SubChainReduct == SQUAREROOT) {
		MaxChainLength = MaxChainLength0/(int)floor(sqrt(n_clu));
    } else {  // no reduction!
	  MaxChainLength = MaxChainLength0;	
	}
}

#endif