//#if __GNUG__ >= 2
//#  pragma implementation
//#endif

#include "SA_Initializer.h"
#include "SA_SeqSolver.h"
#ifdef MPI
  #include "SA_ClusteringSolver.h"
  #include "SA_MIRSolver.h"
  #include "mpi.h"
#endif
#include "util_salib.h"
#include <string.h>
 //#include <crtdbg.h>
#include <signal.h>

//#include "parrandom.h"		// Zufallszahlgenerator

#define USE_SIGNAL 1

SA_Solver * running_solver = NULL;	//Pointer auf die bei Signal zu loeschende Instanz
int nsignals = 0;				// number of caught signals
void 	(*old_sighandler)(int);	// alte Funktion fuer Signal
void	SigintAction(int);		// bei SIGINT

void SigIntAction(int signumber)
{
	// SigIntAction wieder als Reaktion auf SIGINT setzen
	void (*current_sighandler)(int);
	current_sighandler = signal(SIGINT,SigIntAction);  


	std::cout<< "Signal No: "<< signumber << " caught!\n";
	std::cout<< "allready caught "<<nsignals<< " signals!"<<std::endl;
	nsignals++;
	switch(nsignals) {
	  case 1 : std::cout << "Invoking HillClimber!" << std::endl;
			//   sig_handler = signal(SIGINT,SigintAction);
			   running_solver->HillClimber();
			   running_solver->WriteSolution();
			   delete running_solver;
			   std::cout << "Solver deleted!" << std::endl;
			   std::cout << std::flush;
			   if (old_sighandler != NULL) {
				 old_sighandler(signumber);
			   }
			   break;
	  case 2 : std::cout << "Going down!" << std::endl;
			   running_solver->WriteSolution();
			   delete running_solver;
			   std::cout << "Solver deleted!" << std::endl;
			   std::cout << std::flush;
			   if (old_sighandler != NULL) {
				 old_sighandler(signumber);
			   }
			   break;			   
	  case 3 : std::cout << "Aborting, no solution written!!!" << std::endl << std::flush;
			  break;
	}
	exit(0);
};

//---- SA_Initializer ---------------------------------------------------------

SA_Initializer::SA_Initializer()
{//debug(SA_Initializer::SA_Initializer  , myrank);
	ConfigFileName = new char[80];
	strcpy(ConfigFileName,"SA.cfg");	//Default-wert 
	std::cerr << "parSA source code information:" << std::endl;
	std::cerr << "Version: " << SRC_VERS_N << std::endl;
	std::cerr << "Revision: " << SRC_REV_N << std::endl << std::endl;
	#ifdef LAST_TASK
	std::cerr << "task: " << LAST_TASK << std::endl;
	#endif
	std::cerr << "last update: " << SRC_REV_DATE << std::endl;
}

SA_Initializer::~SA_Initializer()
{//debug(SA_Initializer::~SA_Initializer  , myrank);
	delete [] ConfigFileName;
}

// \******************************************************
// Methode ReadConfigFile - Liest die Konfigurations-
// datei, liefert den gewaehlten Solver zurueck 
// \******************************************************
SA_Solver * SA_Initializer::ReadConfigFile(int argc, char **argv, SA_Problem & probl)
{
//debug(SA_Initializer::ReadConfigFile  , myrank);
		std::cout << "argc " << argc << std::endl;
		for(int j=0; j<argc; j++)
		{
			std::cout << "argv[" << j << "] " << argv[j] << std::endl;
		}

// Zufallszahlgenerator initialisieren:

	init_rand(0);
	int i=0;
#ifndef WINNT
//std::cout <<"Argc "<<argc<<" " ;for (i=0;i<argc;i++) std::cout <<argv[i]<<" "; std::cout <<std::endl;
//	i=0;
// Kommandozweile nach dem Namen der .cfg-Datei durchsuchen
	do{
		i++;
	} while ( (i<argc) && strcmp(argv[i], "-cfg") );
	
	if ( i<argc )	// Option -cfg angewandt
	{
		i++;
		if ( i<argc )	// auch ein Parameter da
		{
std::cout <<"The -cfg option can lead to trouble due to error in the mpirun-script!\n";
std::cout <<"Check if configfilename is the same at all processors:\n";
			delete [] ConfigFileName;
			ConfigFileName = new char [ 10*strlen( argv[i] + 1) ];
			if( ConfigFileName == 0 )
			{
				std::cerr << "Insufficient memory" << std::endl;
				exit(0);
			}
			//_ASSERTE( _CrtCheckMemory( ) );
			strcpy(ConfigFileName,argv[i]);
			//_ASSERTE( _CrtCheckMemory( ) );
			//std::cout <<ConfigFileName<<std::endl;

			// extract "-cfg filename" from command line options
			// - move all stringpointers (j) after -cfg xxx 2 positions forward
			// - decrement argc by 2
			for (int j = i+1;j < argc;j++) {
			  argv[j-2] = argv[j];
			}
			argc -= 2;
		}
		else
		{
			std::cout << "Usage: " <<argv[0]<<"[MPI-OPTIONS] [-cfg Filename]\n";
			exit(1);
		}
	}
	
// den Pfad zu der .cfg-Datei bestimmen
	if( *argv[0] == '/')	// falls vollstaendiger Pfad zu der ausgefuehrten Datei vorliegt
	{
		char * buf = ConfigFileName;
		int offset = filename_offset(argv[0]);
		ConfigFileName = new char[ offset + strlen(buf) + 1]; 
		strncpy(ConfigFileName,argv[0],offset);
		strcpy(ConfigFileName+offset,buf);
		delete buf;
	}
 
#endif // WINNT
std::cout <<"ConfigFileName : "<<ConfigFileName <<std::endl;
	
	#ifndef WINNT
		std::ifstream config(ConfigFileName);
	#else
	//_ASSERTE( _CrtCheckMemory( ) );
		std::ifstream config("SA.cfg");
	//_ASSERTE( _CrtCheckMemory( ) );
	#endif
	if (!config || !config.good() )
	{
		std::cout << "Cannot open config file "<< ConfigFileName <<std::endl;
		return NULL;
	}
//	std::cout << "config file is open: " << config.is_open() << std::endl;
	
	SA_Solver * solv = NULL;
	char text[BUFLEN];
	
	config >> text;
	if ( strcmp(text,"{") != 0)
	{
		std::cout << "Config file does not begin with {!\n";
		return NULL;
	}
	
	while ( config >> text && ( strcmp(text,"}") != 0 ))
	{
		if (strcmp(text, "SA_Solver") == 0)
		{
			config >> text;
			if ( strcmp(text, "SA_SeqSolver") == 0)
				{
// To eliminate the MPI switches form the parameters we have to call MPI_Init
#ifdef MPI
					MPI_Init(&argc, &argv);	
#endif 
					solv = new SA_SeqSolver(probl);
				}
#ifdef MPI 

			else if ( strcmp(text, "SA_ClusteringSolver") == 0)
				{
					solv = new SA_ClusteringSolver(&argc,&argv,probl);
				}
			else if ( strcmp(text, "SA_MIRSolver") == 0)
				{
					solv = new SA_MIRSolver(&argc,&argv,probl);
				}
#endif
			else
				{
					std::cout <<"Unkonwn Solver "<<text<<"!\n";
					return 0; 				
				}
			if ( ! solv->ReadConfig(config) )
			{
				std::cout <<"ReadConfing for Solver failed!\n";
				delete	solv;
				return NULL;
			}
		}
		else 
		{
			std::cout <<"In SA_Initializer::ReadConfigFile: unrecognized keyword \""<<text<<"\""<<std::endl;
		}
	}

	if ( strcmp( text, "}") == 0)
	{
		running_solver = solv;
//#ifdef USE_SIGNAL
		old_sighandler = signal(SIGINT,SigIntAction);
		// \*myaction.sa_flags = SA_NODEFER;
		//sigset(SIGINT,);	//Bei SIGINT den Destruktor aufrufen
//#endif

		probl.EvaluateOptions(&argc,&argv);	
		return solv;
	}
	else
	{
		std::cout <<"In SA_Initializer::ReadConfigFile: Config file does not end with }!\n"; 
		delete solv;
		return NULL;
	}
}