/*******************************************************************************
 * Copyright (c) 2016 CEA LIST.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *  Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr
 *   - Initial API and implementation
 ******************************************************************************/

#include "AvmLauncher.h"

#include <base/ClassKindInfo.h>

#include <builder/Builder.h>
#include <builder/Loader.h>

#include <main/SignalHandler.h>

#include <computer/EnvironmentFactory.h>

#include <fam/api/ProcessorUnitRepository.h>

#include <fml/executable/ExecutableLib.h>

#include <fml/expression/ExpressionFactory.h>

#include <fml/runtime/RuntimeLib.h>

#include <fml/type/TypeManager.h>

#include <solver/api/SolverDef.h>
#include <solver/api/SolverFactory.h>

#include <util/avm_string.h>
#include <util/ExecutionTime.h>

#include <boost/filesystem.hpp>

#ifdef _AVM_BUILT_WITH_CMAKE_
#include "version.h"
#include "confs.h"
#endif /*_AVM_BUILT_WITH_CMAKE_*/


namespace sep
{

#define _SYMBEX_VERSION_            3
#define _SYMBEX_VERSION_MAJOR_      6
#define _SYMBEX_VERSION_PATCHLEVEL_ 0


//const unsigned    AvmLauncher::SUBVERSION_REVISION_NUMBER = 4838;
//const std::string AvmLauncher::SUBVERSION_REVISION_STRING = "4838";


#ifdef _GIT_VERSION_

	#define GIT_VERSION   _GIT_VERSION_

#else

//	#define GIT_VERSION "\"$(shell git describe --always --tags)\""
	#define GIT_VERSION "\"$(shell git rev-parse HEAD)\""

#endif


std::string AvmLauncher::SYMBEX_SCM_VERSION = GIT_VERSION;
//		OSS("") << _SYMBEX_VERSION_ << '.' << _SYMBEX_VERSION_MAJOR_;
////			<< '.' << _SYMBEX_VERSION_PATCHLEVEL_;

std::string AvmLauncher::SYMBEX_BUILD_ID = GIT_VERSION;
//		SUBVERSION_REVISION_STRING;

std::string AvmLauncher::SYMBEX_BUILD_INFO =
		OSS("") << "Git-Version< " << SYMBEX_SCM_VERSION << " >";
//		OSS("") << "Version " << SYMBEX_SCM_VERSION
//				<< " build " << SYMBEX_BUILD_ID;


/**
 * LOADER
 */
bool AvmLauncher::load()
{
	copyright();

	if( getArgNumber() > 1 )
	{
		std::string arg;
		for( avm_size_t i = 1 ; i < getArgNumber() ; ++i )
		{
			arg = getArgument( i );

			if( arg[0] != '-' )
			{
				VFS::WorkflowPath = arg;
			}
			else if( (arg.find("--favm=") == 0) || (arg.find("--spec=") == 0) )
			{
				VFS::WorkflowPath =
						arg.substr(std::strlen("--favm="), arg.size());
			}
			else if( (arg == "--favm") || (arg == "--spec") )
			{
				VFS::WorkflowPath = getArgument( ++i );
			}

			else if( arg == "--standalone" )
			{
				AVM_EXEC_MODE_SET( STANDALONE );
			}
			else if( (arg == "--server") || (arg == "-server") )
			{
				AVM_EXEC_MODE_SET( SERVER );
			}
			else if( arg == "--interactive" )
			{
				AVM_EXEC_MODE_SET( INTERACTIVE );
			}

			else if( arg.find("--log=") == 0 )
			{
				AVM_LOG_FILE_LOCATION =
						arg.substr(std::strlen("--log="), arg.size());
			}
			else if( arg == "--log" )
			{
				AVM_LOG_FILE_LOCATION = getArgument( ++i );
			}

			else if( arg.find("--trace=") == 0 )
			{
				AVM_LOG_FILE_LOCATION =
						arg.substr(std::strlen("--trace="), arg.size());
			}
			else if( arg == "--trace" )
			{
				AVM_TRACE_FILE_LOCATION = getArgument( ++i );
			}

			else if( arg.find("--debug=") == 0 )
			{
				avm_setDebugLevel(
						arg.substr(std::strlen("--debug="), arg.size()) );
			}
			else if( arg == "--debug" )
			{
				avm_setDebugLevel( getArgument( ++i ) );
			}

			else if( arg == "--silent" )
			{
				AVM_EXEC_VERBOSITY_SET( MINIMUM );
			}

			else if( arg.find("--verbosity=") == 0 )
			{
				avm_setExecVerbosityLevel(
						arg.substr(std::strlen("--verbosity="), arg.size()) );
			}
			else if( arg == "--verbosity" )
			{
				avm_setExecVerbosityLevel( getArgument( ++i ) );
			}

			else if( (arg == "--enabled-processors-list")
					|| (arg == "--enabled-fam-list") )
			{
				ProcessorUnitRepository::toStreamAll( AVM_OS_COUT );

				ProcessorUnitRepository::toStreamExported( AVM_OS_COUT );
			}
			else if( arg == "--enabled-solvers-list" )
			{
				SolverDef::toStreamSolverList( AVM_OS_COUT );
			}

			else
			{
				AVM_OS_WARNING_ALERT
						<< "Unknown AVM launch option << " << arg << " >> !!!"
						<< SEND_ALERT;
			}
		}
	}
	else
	{
		usage();

		::exit(1);
	}

	/*
	 * LOAD
	 * Predefined FORM
	 */
	XLIA_SYNTAX::load();

	ExpressionFactory::load();

	// after loading parameter...
	//	SolverFactory::load();

	TypeManager::load();


	EnvironmentFactory::load();

	Builder::load();

	ExecutableLib::load();

	RuntimeLib::load();


	mWorkflow.load();

	avm_report(AVM_OS_LOG, "AvmLauncher::load at the end");

	return( true );
}


/**
 * DISPOSER
 */
void AvmLauncher::dispose()
{
	EnvironmentFactory::dispose();

	SolverFactory::dispose();


	mWorkflow.dispose();


	RuntimeLib::dispose();

	ExecutableLib::dispose();

	Builder::dispose();


	TypeManager::dispose();

	ExpressionFactory::dispose();

	XLIA_SYNTAX::dispose();

	copyright();
}


/*******************************************************************************
 * Copyright (c) 2016 CEA LIST.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *  Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr
 *   - Initial API and implementation
 ******************************************************************************/
void AvmLauncher::copyright()
{
	AVM_OS_COUT << std::endl << AVM_TAB1_INDENT
			<< TAB << "SYMBEX< DIVERSITY > "

#ifndef _AVM_BUILT_WITH_CMAKE_

			<< SYMBEX_BUILD_INFO
#else
			<< sources_commit_id << " built on " << system_name

#endif /*_BUILT_WITH_CMAKE_*/

			<< " @ " << __DATE__ << std::endl
			<< TAB << "2010 - 2016 CEA List" << std::endl
//			<< TAB << "1998 - 2013 CEA List" << std::endl
			<< TAB << "All Rights Reserved" << std::endl
			<< TAB << "Launch @ " << ExecutionTime::current_time()
			<< std::endl << END_INDENT;
}


/**
 * AvmLauncher::usage
 *
 */
void AvmLauncher::usage()
{
	AVM_OS_LOG << " Usage :> avm.exe parameterfile (in FAVM format)" << std::endl;

	std::cin.get();
}


/**
 * AvmLauncher::start
 *
 */
void AvmLauncher::start()
{
	/*
	 * INITIALIZATION
	 * parameter FORM
	 */
	if( not mWorkflow.loadConfiguration(VFS::WorkflowPath) )
	{
		return;
	}

	SolverFactory::load();

	/*
	 * RUNNING
	 * parameter FORM
	 */
	try
	{
		SignalHandler::setSIGINT_handler();

		if( mWorkflow.configure() )
		{
			mWorkflow.startComputing();
		}
	}
	catch ( const std::exception & e )
	{
		AVM_OS_WARN << std::endl << EMPHASIS(
				"AvmLauncher::start< std::exception >", e.what(), '*', 80);
	}
	catch ( ... )
	{
		AVM_OS_WARN << std::endl << EMPHASIS(
				"AvmLauncher::start< unknown::exception > !!!", '*', 80);
	}
}


int AvmLauncher::run( int argc , char * argv[] )
{
	if( argv != NULL )
	{
		VFS::ExecutablePath = argv[0];
	}
	VFS::LaunchPath = boost::filesystem::current_path().string();

	ClassKindInfoInitializer::load();

	std::string strAction = " The AvmLauncher::main";

	OutStream::load();

	try
	{
		sep::AvmLauncher theAvmLauncher(
				(argc < 0)? 0 : static_cast< avm_size_t >(argc) , argv);

		strAction = " The AvmLauncher::load";
		if( theAvmLauncher.load() )
		{
			switch( _AVM_EXEC_MODE_ )
			{
				case AVM_EXEC_STANDALONE_MODE:
				case AVM_EXEC_SERVER_MODE:
				case AVM_EXEC_INTERACTIVE_MODE:
				default:
				{
					if( not VFS::WorkflowPath.empty() )
					{
						VFS::WorkflowPath = VFS::native_path(
								VFS::WorkflowPath, VFS::LaunchPath);

						if( VFS::checkReadingFile( VFS::WorkflowPath ) )
						{
							strAction = " TheAvmLauncher::start";

							theAvmLauncher.start();

							avm_report(AVM_OS_LOG,
									"AvmLauncher::run after this.start()");
						}
						else
						{
							AVM_OS_CERR << _SEW_ << "< error >"
									" Unreadable or non-existent file !"
									<< std::endl
									<< _SEW_ << "< info  > Launch path : "
									<< VFS::LaunchPath << std::endl;

							avm_set_exit_code( AVM_EXIT_CONFIGURE_ERROR_CODE );
						}
					}
					break;
				}
			}
		}

		strAction = " The AvmLauncher::dispose";

		theAvmLauncher.dispose();
	}
	catch ( const std::exception & e )
	{
		AVM_OS_WARN << std::endl << EMPHASIS(
			(strAction + "< std::exception > "), e.what(), '*', 80);
	}
	catch ( ... )
	{
		AVM_OS_WARN << std::endl << EMPHASIS(
			(strAction + "< unknown::exception > !!!"), '*', 80);
	}


	avm_report(AVM_OS_LOG, "::main at the end");

AVM_IF_DEBUG_FLAG( REFERENCE_COUNTING )

	avm_report(AVM_OS_COUT, "::main at the end");

AVM_ENDIF_DEBUG_FLAG( REFERENCE_COUNTING )


	OutStream::dispose();

	ClassKindInfoInitializer::dispose();

	AVM_OS_COUT << exit_msg( _AVM_EXIT_CODE_ );

	return( _AVM_EXIT_CODE_ );
}


} /* namespace sep */