// \******************************************************
// Datei Scheduler.h
// Autor: Peter Unruh, basierend auf der PG-Version
// \****************************************************** 
 
#ifndef SA_Scheduler_H
#define SA_Scheduler_H

//#include	<iostream.h>
//#include	<fstream.h>
#include	<iostream>
#include	<fstream>
#include 	<time.h>
///#include	<mpi.h>

#include    <SA_Output.h>
#include	"constants.h"
#include 	<SA_Problem.h>
#include	"parrandom.h"		// Zufallszahlen


// \******************************************************
// Klasse Scheduler :
//	cooling schedule, Statistiken 
// von dieser Klasse muss jeder Scheduler abgeleitet werden
// \****************************************************** 
class SA_Scheduler
{
private:
	SA_Output saoutput;
	char opttypename[4];		// is "MINIMIZE" if opttype is MIN and "MAXIMIZE" if opttype is MAX
	char warminguptype[15];		// describtion of recommended warming up
								// Scheduler: StartT, Aarts, FixedAarts
	int wt;					// flag


protected:
	clock_t starttime;
	long timelimit;
	
	int		BestFlag;		// Aktuelle Energie ist die beste bis jetzt

	float 	StartT, T;		// Anfangstemperatur und aktuelle Temperatur
	float   InitAccRatio;  // -1 or the user requested initial accaptance ratio
	float 	AccRatio;      // n_accepts / n_iter only needed for output

	unsigned long
			n_iter,			// Laenge der Kette bei akt. Temperatur
			n_accepts, 		// Anzahl der akzeptierten Uebergaenge bei akt. Temperatur
			n_updates,		// Anzahl der tatsaechlich erfolgten Uebergaenge bei akt. Temperatur
			n_dT,			// Anzahl der Temperaturstufen
			total_iter,		// Gesamtlaenge der Kette
			i_subchain,		// Iterationsnummer des ersten Elementes der Teilkette (bei geg. Temperatur)
			total_accepts,	// Gesamtzahl der akzeptierten Uebergange
			total_updates,	// Gesamtzahl der erfolgten Uebergaenge
			overall_iter;   // total_iter ueber Gesamtezahl aller Laeufe (total_iter ohne ruecksetzen durch reset())
			
	float	E,				// Aktuelle Energie (akt. Kosten)
			StartE,			// Energie der Initialloesung
			BestE,			// Beste bis jetzt gesehene Energie
			ThresholdValue; // >1, new solution must be better than BestE*ThresholdValue to be accepted
	double	Sum,Sum2;		// Summe der Energien und Quadrate der Energien bei akt. Temperatur
	double	SumRun, Sum2Run;// Summe der Energien und Quadrate der Energien im ganzen Run
	
	char*	PictureDirectory;

	std::ofstream	CostFunction,
				Temperature,
				BestCostFunktion;
				
			
				
public:

	 double		  AartsWarmingUp(SA_Problem &, SA_Solution &, SA_Solution &,long);
	 // is true if no startT was set in Scheduler or if both startT AND initaccratio where set
	 int 		  AartsRecommended();
	 virtual void WarmingUp(SA_Problem &, SA_Solution &, SA_Solution &); 
	// die Bestimmung der Cooling-Parameter;
	// bekommt in s eine Initialloesung, liefert in b beste gesehene
	// Anforderung : MUSS StartE setzen !	

	virtual int		Equilibrium() = 0;
	virtual void	UpdateTemperature() = 0; 
	virtual int		Frozen() = 0;

// Steuerung des Durchlaufs
	virtual int		TryAcceptance(float new_cost);	// prueft, ob ein Uebergang akzeptiert wird; zaehlt Akzeptanzen	
	virtual int		Accept(float new_cost);			// prueft und fuehrt einen Uebergang ggf. durch; zaehlt Updates

	SA_Scheduler();
 	virtual ~SA_Scheduler();
 	virtual SA_Output *GetSchedulerOutput();
 		
// Manipulation of E, StartE, BestE
	void	SetStartE(float e) {SetNewE(StartE=e);SetStartT(StartT);}	// Wert der Startloesung setzen
	float	GetStartE(){return StartE;}
	void	SetNewE(float e);					// neue Energie setzte (Kette um Eins verlaengern); modifiziert n_updates
	void	LetOldE(int numb=1);				// das System bleibt im alten Zustand; Kette um numb verlaengern
	float	GetE() {return E;}					// liefert aktuelle Energie
	float	GetBestE(){ return BestE;}
	virtual void ResetBestE();					// BestE wird zurueckgesetzt, wird in Solver::InitStates aufgerufen

// Manipulation of StartT, T
	void	SetStartT(float t);					// Anfangstemperatur setzen
	float	GetStartT(void) {return StartT;}
	float	GetRelativeT() {return T/StartT;}	// liefert Zahl aus [0,1] entsprechend der aktuellen Temperatur
	void 	SetNewT(float t);					// neue Temperatur setzten
	float	GetT() {return T;}					// liefert aktuelle Temperatur

	int		BestFound() {return BestFlag;}		// TRUE <=> akt.Energie ist bis jetzt die beste

	int		Better(float a, float b);			// TRUE <=> a "besser" als b

// Reading the variables
	unsigned long	GetTotalIter(){return total_iter;}
	unsigned long	GetNIter(){return n_iter;}
	unsigned long	GetTotalAccepts(){return total_accepts;}
	unsigned long	GetTotalUpdates(){return total_updates;}

// Statistic information
	float GetMean();							// Mittlere Energie bei akt. Temperatur bestimmen
	float GetSigma();							// Standardabweichung bei akt. Temperatur bestimmen
	float GetRunMean();							// Mittlere Energie im Run
	float GetRunSigma();						// Standardabweichung beim Run 
	float GetAcceptRatio();		
	float GetUpdateRatio();

	virtual void Reset();						// den SA_Scheduler nach einem SA-Lauf zuruecksetzen, Einstellungen beibehalten
	
// Input and Output
	virtual int ReadConfig(std::istream &);
	virtual void ShowConfig(std::ostream &);

//	void OutputStatistics(std::ostream &);			// Statistiken des Durchlaufs hinschreiben (OHNE endl davor oder danach !!)
	void OutputSubchainStatistics(std::ostream &);	// Statistiken der Teilkette hinschreiben (OHNE endl davor oder danach !!)

	virtual void CreateLog(std::ostream &);
	
	void StartClock();
	int TimeExceeded();	
};

#endif