//#include <iostream.h>
//#include <stream.h>
//#include <fstream.h>
//#include <iomanip.h>
#include <fstream>
#include <iomanip>
#include <my_math.h>
//#include <stdlib.h>
#include <string.h>
#include "SA_SeqAartsScheduler.h"

//#define debug(r,m) std::cout << " +++ " << #r << " +++" << std::endl;


SA_SeqAartsScheduler::SA_SeqAartsScheduler() :
	GlobalBestE(INFINITY),
	subchainfactor(1),
	delta(0.1),
	epsilon(0.0001),
	omega(0.8),
	L(100),
	L0(100),
	n_smooth(10),
	SmoothedMean(0),
	saaartsoutput("SA_SeqAartsScheduler","SA_Output.rsc")
{//debug(SA_SeqAartsScheduler::Konstruktor  ,myrank);
	// Connecting instances to SA_Output object
	saaartsoutput.EnableLevelNumbers(false);
	saaartsoutput.EnableIdentifier(true);
	saaartsoutput.SetOutputLevel(10);

	saaartsoutput.AddVariable(1, SA_FLOAT, &subchainfactor);
	saaartsoutput.AddVariable(2, SA_FLOAT, &delta);
	saaartsoutput.AddVariable(3, SA_FLOAT, &epsilon);
	saaartsoutput.AddVariable(4, SA_FLOAT, &omega);
	saaartsoutput.AddVariable(5, SA_LONG, &L);
	saaartsoutput.AddVariable(6, SA_LONG, &L0);
	saaartsoutput.AddVariable(7, SA_LONG, &n_smooth);
	saaartsoutput.AddVariable(8, SA_FLOAT, &SmoothedMean);
	saaartsoutput.AddVariable(9, SA_FLOAT, &LastSmoothedMean);
	saaartsoutput.AddVariable(10, SA_FLOAT, &LastT);
	saaartsoutput.AddVariable(11, SA_FLOAT, &MeanbyT0);
	saaartsoutput.AddVariable(12, SA_FLOAT, &GlobalBestE);
	
	saaartsoutput.SetPreviousOutput(SA_Scheduler::GetSchedulerOutput());

//	AverageCost		= new float[n_smooth];
//	SmoothingFactor	= new float[n_smooth];
//	for (int i=0; i < n_smooth; i++)
//	{
//		AverageCost[i] = 0;
//		SmoothingFactor[i] = 1;
//	}
}

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

//	delete [] AverageCost;	

}

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

	char text[BUFLEN];
	config >> text;
	if ( strcmp(text,"{") != 0)
	{
		std::cout << "In SA_SeqAartsScheduler::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, "delta") == 0)
		{
		  config >> text;
		  delta = atof(text);
		}
	  else if (strcmp(text, "subchainfactor") == 0)
		{
		  config >> text;
		  subchainfactor = atof(text);
		}
	  else if (strcmp(text, "epsilon") == 0)
		{
		  config >> text;
		  epsilon = atof(text);
		}
	  else if (strcmp(text, "omega") == 0)
		{
		  config >> text;
		  omega = atof(text);
		}
	  //	  else if (strcmp(text, "initialtemperature") == 0)
	  //		{
	  //		  config >> text;
	  //		  SetStartT( atof(text) );
	  //		}
	  else
		{
			std::cout <<"In SA_SeqAartsScheduler::ReadConfig: unrecognized keyword \""<<text<<"\""<<std::endl;
		}
	}

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



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

// set the subchain length
	L0 = L = (unsigned long)ceil(P.GetLocalN() * subchainfactor);

	if(AartsRecommended())	// if StartT wasn't set in .cfg-file 
	{
// use the Aarts-Method for calculating T0
		double T_buffer = AartsWarmingUp(P ,s ,b ,L);
		MeanbyT0 = GetMean();
		SmoothedMean = GetE();
		SetStartT(T_buffer);
	}
	else
	{
		MeanbyT0 = SmoothedMean = P.GetCost(s);
	}
}


// die Anzahl der Cluster dem Scheduler mitteilen:
//  die Laenge der Kette an den einzelnen Prozessoren wird angepasst 
// void SA_SeqAartsScheduler::SetClusterNumber(unsigned long n_clu, unsigned long clu_size)
// {
// 	n_cluster= n_clu;
//	cluster_size = clu_size;
//	L = L0/n_clu;
//	L = L0/(int)floor(sqrt(n_clu));
//}

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

//	out << "SA_SeqAartsScheduler Konfiguration:" << std::endl;
//
//	SA_Scheduler::ShowConfig(out);
//	
//	out		<< "\tLoopFactor:  " << subchainfactor << std::endl
//			<< "\tDelta:  " << delta << std::endl
//			<< "\tAkzeptanzrate(0):  " << InitAccRatio << std::endl
//			<< "\tStopparameter:  " << epsilon << std::endl
//			<< "\tAnfangstemperatur: " << StartT << std::endl;
}


// \******************************************************
// Methode Output - Schreibt die Ergebnisse in die
// Logdatei.
// \******************************************************
void SA_SeqAartsScheduler::CreateLog(std::ostream & out)
{//debug(SA_SeqAartsScheduler::Output  , myrank);
	
	out << "Sched=Aarts" << " LoopFct="<<subchainfactor;

	
	SA_Scheduler::CreateLog(out);
	
	//		<< " smooth=" << n_smooth 
	out << " d="     //		out	<< " Mean=" << GetMean();
            << delta 
	    << " eps=" << epsilon;
}


// \******************************************************
// Methode UpdateTemperature : neue Temperatur lokal bestimmen 
// \******************************************************
void SA_SeqAartsScheduler::UpdateTemperature()
{//debug(SA_SeqAartsScheduler::UpdateTemperature  , myrank);

// T ist die aktuelle Temperatur
// Setze neue Temperatur mittels SetNewT
	
//	std::ofstream output1("for_gnuplot_Mean", ios::app);
//	std::ofstream output2("for_gnuplot_SmoothedMean", ios::app);
//	std::ofstream output3("for_gnuplot_Temperature", ios::app);

	float newT = T;
	LastT = T;

	if ( (GetSigma() > 0) && (delta != -1) )
	{
		newT = T / ( 1 + (log(1+delta)*T)/(3*GetSigma()) );
	}
	
	LastSmoothedMean = SmoothedMean;
	SmoothedMean = (1-omega)*GetMean() + omega*SmoothedMean;

//if (me == 0)
//{
//	std::cout<<"Wartezeiten: "<<1.0/mean_update_ratio<<" "<<1.0/(1-pow(1-mean_accept_ratio,nproc))<<"                 "<<1.0/mean_accept_ratio<<std::endl;
//}
//std::cout<<me<<" "<<total_iter<<" "<<n_iter<<" "<<GetMeanAcceptRatio(comm)<<" "<<GetMeanUpdateRatio(comm)<<std::endl;
//	output3	<< T << std::endl;
//
//	output1.close();
//	output2.close();
//	output3.close();

	SetNewT( newT );

}

// \******************************************************
// Methode Equilibrium - Entscheidet, ob im gegebenen
// Schleifendurchlauf das Gleichgewicht erreicht wurde.
// \******************************************************
int SA_SeqAartsScheduler::Equilibrium()
{//debug(SA_SeqAartsScheduler::Equilibrium  , myrank);
 
	return( TimeExceeded() || n_iter > L);
}


// \******************************************************
// Methode Frozen - Entscheidet, ob der Algorithmus
// zum Stillstand gekommen ist.
// \******************************************************
int SA_SeqAartsScheduler::Frozen()
{//debug(SA_SeqAartsScheduler::Frozen  , myrank);
   if (TimeExceeded()) {
	 return 1;
   } else {
	float	Ableitung = 0,
			Z;			// siehe Formel bei Aarts
	
	if ( LastT != T )
	{
		Ableitung = ( SmoothedMean - LastSmoothedMean ) / ( T - LastT );
		Z = FABS( Ableitung * T / MeanbyT0 );
	} else {
	  Z = 0;
	}
	return ( Z <= epsilon )? 1 : 0;
   }
}