/***************************************
	Auteur : Pierre Aubert
	Mail : pierre.aubert@lapp.in2p3.fr
	Licence : CeCILL-C
****************************************/

#include "string_utils.h"
#include "PEmptyControlBackend.h"

///Create a PEmptyControlParam
/**	@param logDirectory : directory where to put logs
 * 	@param logLevel : level of log to be used in the backend
 * 	@return corresponding PEmptyControlParam
*/
PEmptyControlParam phoenix_emptyControlParam(const std::string & logDirectory, PLog::Level logLevel){
	PEmptyControlParam param;
	param.logDirectory = logDirectory;
	param.logLevel = logLevel;
	return param;
}

///Create a PEmptyManagerParam
/**	@param name : name of the manager
 * 	@param logDirectory : directory where to put logs
 * 	@param logLevel : level of log to be used in the backend
 * 	@return corresponding PEmptyManagerParam
*/
PEmptyManagerParam phoenix_emptyManagerParam(const std::string & name, const std::string & logDirectory, PLog::Level logLevel){
	PEmptyManagerParam param;
	param.name = name;
	param.logDirectory = logDirectory;
	param.logLevel = logLevel;
	return param;
}

///Create a default Param
/**	@param logDirectory : directory where to put logs
 * 	@param logLevel : level of log to be used in the backend
 * 	@return corresponding PEmptyControlParam
*/
PEmptyControlBackend::Param PEmptyControlBackend::defaultParam(const std::string & logDirectory, PLog::Level logLevel){
	return phoenix_emptyControlParam(logDirectory, logLevel);
}

///Create a default MgrParam
/**	@param name : name of the manager
 * 	@param logDirectory : directory where to put logs
 * 	@param logLevel : level of log to be used in the backend
 * 	@return corresponding PEmptyControlParam
*/
PEmptyControlBackend::MgrParam PEmptyControlBackend::defaultMgrParam(const std::string & name, const std::string & logDirectory, PLog::Level logLevel){
	return phoenix_emptyManagerParam(name, logDirectory, logLevel);
}

///Contructor of the empty Backend
PEmptyControlBackend::PEmptyControlBackend(){
	
}

///Initialise the manager
/**	@param[out] manager : manager to be initialised
 * 	@param param : parameters to be used to initialise the manager data
 * 	@return true on success, false otherwise
*/
bool PEmptyControlBackend::initialiseDataManager(PEmptyControlBackend::Manager & manager, const PEmptyControlBackend::MgrParam & param){
	manager.name = param.name;
	PLog & logger = manager.logger;
	std::string logDirectory(param.logDirectory);
	createDirectoriesIfNotExist(logDirectory);
	logger.setFileName(logDirectory + "/manager_"+manager.name+".log");
	logger.setLogLevel(param.logLevel);
	if(!logger.open()){return false;};
	logger.getLogInfo() << "Create Empty Manager '"<<manager.name<<"'" << std::endl;
	return true;
}

///Create a client connector
/**	@param manager : manager to be used to initialise connector
 * 	@param[out] connector : connector to be created
 * 	@param address : address of the server, the client has to connect to
 * 	@param param : extra customisable parameters for the creation of the connector (depends on the backend)
 * 	@return true if the connector has been created, false otherwise
*/
bool PEmptyControlBackend::createClientConnector(PEmptyControlBackend::Manager & manager, PEmptyControlBackend::Connector & connector,
				const std::string & address, const PEmptyControlBackend::Param & param)
{
	return PEmptyControlBackend::createConnector(manager, connector, "client", address, param);
}

///Create a server connector
/**	@param manager : manager to be used to initialise connector
 * 	@param[out] connector : connector to be created
 * 	@param address : address of the server, the client has to connect to
 * 	@param param : extra customisable parameters for the creation of the connector (depends on the backend)
 * 	@return true if the connector has been created, false otherwise
*/
bool PEmptyControlBackend::createServerConnector(PEmptyControlBackend::Manager & manager, PEmptyControlBackend::Connector & connector,
				const std::string & address, const PEmptyControlBackend::Param & param)
{
	return PEmptyControlBackend::createConnector(manager, connector, "server", address, param);
}

///Regiter a variable which can be used by the given connector
/**	@param connector : connector to be used
 * 	@param composeVar : variable to be used (can have a complex type)
 * 	@return true on success, false otherwise
*/
bool PEmptyControlBackend::registerVar(PEmptyControlBackend::Connector & connector, const PComposeVar & composeVar){
	PLog & logger = *connector.logger;
	logger.getLogInfo() << "Register Var '"<<ts_pcomposeVarToStr(composeVar)<<"' to host '"<<connector.hostname<<"'" << std::endl;
	return true;
}

///Regiter a method which can be called by the given connector
/**	@param connector : connector to be used
 * 	@param prototype : prototype of the method to be called
 * 	@return true on success, false otherwise
*/
bool PEmptyControlBackend::registerCall(PEmptyControlBackend::Connector & connector, const PFunctionPrototype & prototype){
	PLog & logger = *connector.logger;
	logger.getLogInfo() << "Register Call '"<<ts_protoTypeToStr(prototype)<<"' to host '"<<connector.hostname<<"'" << std::endl;
	return true;
}

///Push a value in the server/client describes by the connector
/**	@param connector : connector to be used
 * 	@param varName : name of the variable to be pushed
 * 	@param value : value of the variable to be pushed
 * 	@return true on success, false otherwise
*/
bool PEmptyControlBackend::push(PEmptyControlBackend::Connector & connector, const std::string & varName, const PEmptyControlBackend::Message & value){
	PLog & logger = *connector.logger;
	logger.getLogInfo() << "Some empty Push to host '"<<connector.hostname<<"' and variable '"<<varName<<"'" << std::endl;
	return true;
}

///Pull value from a server/client
/**	@param[out] connector : connector to be used
 * 	@param varName : variable name to pull the value from
 * 	@param[out] value : pulled binary data
 * 	@return true on success, false otherwise
*/
bool PEmptyControlBackend::pull(PEmptyControlBackend::Connector & connector, const std::string & varName, PEmptyControlBackend::Message & value){
	PLog & logger = *connector.logger;
	logger.getLogInfo() << "Some empty pull from host '"<<connector.hostname<<"' and variable '"<<varName<<"'" << std::endl;
	return true;
}

///Call method on a server/client
/**	@param[out] connector : connector to be used
 * 	@param methodCall : method to be called
 * 	@return true on success, false otherwise
*/
bool PEmptyControlBackend::call(PEmptyControlBackend::Connector & connector, PFunctionCall & methodCall){
	PLog & logger = *connector.logger;
	logger.getLogInfo() << "Some call of method '"<<methodCall.getPrototype().getName()<<"' to host '"<<connector.hostname<<"'" << std::endl;
	return true;
}

///Resize a message
/**	@param[out] msg : message to be resized
 * 	@param sizeMsg : new size of the message
*/
void PEmptyControlBackend::msgResize(PEmptyControlBackend::Message& msg, size_t sizeMsg){
	msg.resize(sizeMsg);
}

///Get the size of Message in bytes
/**	@param msg : given message
 * 	@return size of the given message in bytes
*/
size_t PEmptyControlBackend::msgSize(const PEmptyControlBackend::Message& msg){
	return msg.size();
}

///Get the data pointer of the given message
/**	@param msg : given message
 * 	@return data pointer of the given message
*/
const char* PEmptyControlBackend::msgData(const PEmptyControlBackend::Message& msg){
	return (const char*)msg.data();
}

///Get the data pointer of the given message
/**	@param msg : given message
 * 	@return data pointer of the given message
*/
char* PEmptyControlBackend::msgData(PEmptyControlBackend::Message& msg){
	return (char*)msg.data();
}

///Close the Connector
/**	@param connector : connector to be closed
*/
void PEmptyControlBackend::close(PEmptyControlBackend::Connector & connector){
	PLog & logger = *connector.logger;
	logger.getLogInfo() << "Close Empty connection with host '"<<connector.hostname<<"'" << std::endl;
}

///Close the Manager
/**	@param manager : manager to be closed
*/
void PEmptyControlBackend::closeMgr(PEmptyControlBackend::Manager & manager){
	PLog & logger = manager.logger;
	logger.getLogInfo() << "Close Empty connection with Manager '"<<manager.name<<"'" << std::endl;
}

///Say if the given Connector is connected to its host or not
/**	@param connector : connector to be used
 * 	@return true if the given Connector is connected to its host, false otherwise
*/
bool PEmptyControlBackend::isConnected(PEmptyControlBackend::Connector & connector){
	PLog & logger = *connector.logger;
	logger.getLogInfo() << "Check Empty connection with host '"<<connector.hostname<<"' but as we are optimistic, let's say the connection is OK" << std::endl;
	return true;
}

///Register a local variable
/**	@param manager : Manager to be used
 * 	@param composeVar : description of the varaible to be registered
 * 	@return true on success, false otherwise
*/
bool PEmptyControlBackend::registerLocalVar(PEmptyControlBackend::Manager & manager, const PComposeVar & composeVar){
	PLog & logger = manager.logger;
	logger.getLogInfo() << "Register local variable '"<<ts_pcomposeVarToStr(composeVar)<<"' to EmptyManager '"<<manager.name<<"'" << std::endl;
	return true;
}

///Get value of local variable
/**	@param manager : Manager to be used
 * 	@param[out] localVar : local variable to be updated
 * 	@return true on success, false otherwise
*/
bool PEmptyControlBackend::getLocalVar(PEmptyControlBackend::Manager & manager, PComposeVar & localVar){
	PLog & logger = manager.logger;
	logger.getLogInfo() << "EmptyManager '"<<manager.name<<"' : get local variable '"<<ts_pcomposeVarToStr(localVar)<<"'" << std::endl;
	return true;
}

///Set value of local variable
/**	@param manager : Manager to be used
 * 	@param localVar : local variable to be written
 * 	@return true on success, false otherwise
*/
bool PEmptyControlBackend::setLocalVar(PEmptyControlBackend::Manager & manager, const PComposeVar & localVar){
	PLog & logger = manager.logger;
	logger.getLogInfo() << "EmptyManager '"<<manager.name<<"' : set value of local variable '"<<ts_pcomposeVarToStr(localVar)<<"'" << std::endl;
	return true;
}

///Create a generic connector
/**	@param manager : manager to be used to initialise connector
 * 	@param[out] connector : connector to be created
 * 	@param connectorType : type of the conenctor (client or server)
 * 	@param address : address of the server, the client has to connect to
 * 	@param param : extra customisable parameters for the creation of the connector (depends on the backend)
 * 	@return true if the connector has been created, false otherwise
*/
bool PEmptyControlBackend::createConnector(PEmptyControlBackend::Manager & manager, PEmptyControlBackend::Connector & connector, const std::string & connectorType,
					const std::string & address, const Param & param)
{
	connector.logger = &manager.logger;
	connector.hostname = address;
	PLog & logger = *connector.logger;
	std::string logDirectory(param.logDirectory);
	logger.getLogInfo() << "Create Empty "<<connectorType<<" Connector" << std::endl;
	return true;
}