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

#include <sstream>

#include "data_stream_check_value.h"
#include "PMockBackend.h"

///Default constructor of PMockBackend
PMockBackend::PMockBackend(){
	
}

///Create param for a client socket
/**	@param address : address of the server to be connected to
 * 	@param port : port to be used
 * 	@param isMockRecord : true if the mock is in record mode
 * 	@param mockDirectory : directory where to find/save mocks
 * 	@return corresponding parameters
*/
PMockBackend::Param PMockBackend::client(const std::string & address, size_t port, bool isMockRecord, const std::string & mockDirectory){
	PMockBackend::Param param;
	param.address = address;
	param.port = port;
	param.isMockRecord = isMockRecord;
	param.mockDirectory = mockDirectory;
	return param;
}

///Create param for a server socket
/**	@param address : address of the server to be connected to
 * 	@param port : port to be used
 * 	@param isMockRecord : true if the mock is in record mode
 * 	@param mockDirectory : directory where to find/save mocks
 * 	@return corresponding parameters
*/
PMockBackend::Param PMockBackend::server(const std::string & address, size_t port, bool isMockRecord, const std::string & mockDirectory){
	return PMockBackend::client(address, port, isMockRecord, mockDirectory);
}

///Create a client socket
/**	@param[out] socket : socket to be created
 * 	@param param : extra customisable parameters for the creation of the socket (depends on the backend)
 * 	@return true if the socket has been created, false otherwise
*/
bool PMockBackend::createClientSocket(PMockBackend::Socket & socket, const PMockParam & param){
	socket.param = param;
	socket.eventIndex = 0lu;
	std::stringstream socketFileName;
	if(param.mockDirectory != ""){
		socketFileName << param.mockDirectory << "/";
	}
	socketFileName << param.address << "_" << param.port << ".pmockbackend";
	socket.fileNameMessage = socketFileName.str();
	bool b(true);
	if(!socket.param.isMockRecord){	//If we are not in record mode, we load all the exchange
		b &= data_load(socket.fileNameMessage, socket.vecMessage);
	}
	return b;
}

///Create a client socket
/**	@param[out] socket : socket to be created
 * 	@param param : extra customisable parameters for the creation of the socket (depends on the backend)
 * 	@return true if the socket has been created, false otherwise
*/
bool PMockBackend::createServerSocket(PMockBackend::Socket & socket, const PMockParam & param){
	return createClientSocket(socket, param);
}

///Send message on the given socket
/**	@param socket : socket to be used
 * 	@param msg : message to be sent
 * 	@param flag : flag to be used to send the message (BLOCK, NON_BLOCK, etc)
 * 	@return true on success, false otherwise
*/
bool PMockBackend::send(PMockBackend::Socket & socket, const PMockBackend::Message & msg, PSendFlag::PSendFlag flag){
	bool b(true);
	if(socket.param.isMockRecord){	//If we record all events
		socket.vecMessage.push_back(msg);
	}else{
		if(socket.vecMessage.size() == 0lu){
			std::cerr << "PMockBackend::send : empty vector of message" << std::endl;
			return false;
		}
		//Let's pick the current message
		if(socket.eventIndex >= socket.vecMessage.size()){
			socket.eventIndex = 0lu;	//Let's loop if all the events were used
		}
		//Let's check if the current message matches the message we are supposed to send
		std::stringstream strEvent;
		strEvent << socket.eventIndex;
		b &= checkValue("PMockBackend::send : event " + strEvent.str(), msg, socket.vecMessage[socket.eventIndex]);
	}
	++socket.eventIndex;
	return b;
}

///Recieve message from the given socket
/**	@param socket : socket to be used
 * 	@param msg : message to be recieved
 * 	@param flag : flag to be used to send the message (BLOCK, NON_BLOCK, etc)
 * 	@return true on success, false otherwise
*/
bool PMockBackend::recv(PMockBackend::Socket & socket, PMockBackend::Message & msg, PRecvFlag::PRecvFlag flag){
	if(socket.param.isMockRecord){	//If we record all events
		socket.vecMessage.push_back(msg);
	}else{
		if(socket.vecMessage.size() == 0lu){
			std::cerr << "PMockBackend::recv : empty vector of message" << std::endl;
			return false;
		}
		//Let's pick the current message
		if(socket.eventIndex >= socket.vecMessage.size()){
			socket.eventIndex = 0lu;	//Let's loop if all the events were used
		}
		msg = socket.vecMessage[socket.eventIndex];
	}
	++socket.eventIndex;
	return true;
}

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

///Get the size of a message
/**	@param msg : message to be used
 * 	@return size of the message in bytes
*/
size_t PMockBackend::msgSize(const PMockBackend::Message& msg){
	return msg.size();
}

///Get the data of a message
/**	@param msg : message to be used
 * 	@return data of the message in bytes
*/
const char* PMockBackend::msgData(const PMockBackend::Message& msg){
	return msg.data();
}

///Get the data of a message
/**	@param msg : message to be used
 * 	@return data of the message in bytes
*/
char* PMockBackend::msgData(PMockBackend::Message& msg){
	return msg.data();
}

///Close the given socket
/**	@param[out] socket : socket to be closed
*/
void PMockBackend::close(PMockBackend::Socket & socket){
	if(socket.param.isMockRecord){
		data_save(socket.fileNameMessage, socket.vecMessage);
	}
}

///Say if the given socket is connected
/**	@param socket : socket to be checked
 * 	@return true if the socket is connected, false otherwise
*/
bool PMockBackend::isConnected(const PMockBackend::Socket & socket){
	return true;
}