/*
 * BusClient.cc
 *
 *  Created on: Jun 7, 2010
 *      Author: lamikr
 */

#include <malloc.h>
#include <plp/log.h>
#include <plp/retval.h>

#include "BusClient.hh"
#include "ClientServerCommon.hh"
#include "BusMessageInternal.hh"
#include "RequestResponseBus.hh"

using namespace std;
using namespace plpbus;
using namespace plpbus_orb;

class OrbClientImpl : public virtual POA_plpbus_orb::OrbClient {
	private:
		IClientListener	*listener;
	public:
		OrbClientImpl(IClientListener *listener_param)	{
			listener	= listener_param;
		}
		virtual ~OrbClientImpl() {}

		virtual void receive_event_message(const char *event_param) {
			if (listener != NULL) {
				listener->event_received(event_param);
			}
		}

		virtual void receive_event_dataitem_sequence(const ::plpbus_orb::DataItemSequence& event_param) {
			BusMessageInternal	*bus_msg;

			if (listener != NULL) {
				bus_msg	= new BusMessageInternal(event_param);
				listener->event_received(bus_msg);
			}
		}

		virtual void receive_response_message(const char *msg_rsp_param) {
			if (listener != NULL) {
				listener->response_received(msg_rsp_param);
			}
		}

		virtual void receive_response_dataitem_sequence(const ::plpbus_orb::DataItemSequence& msg_rsp_param) {
			const BusMessageInternal	*bus_msg;

			if (listener != NULL) {
				bus_msg	= new BusMessageInternal(msg_rsp_param);
				listener->response_received(bus_msg);
				delete(bus_msg);
			}
		}
};

BusClient::BusClient()
{
	log_debug("created\n");;
	_orb		= NULL;
	_poa		= NULL;
}

BusClient::~BusClient()
{
	if (_poa != NULL) {
		//_poa->destroy(true, true);
	}
	if (_orb != NULL) {
		_orb->destroy();
		_orb	= NULL;
	}
	log_debug("destroyed\n");
}

int BusClient::init(const char *server_name) {
	int			argc;
	char			**argv;
	CORBA::Object_var	server_obj;
	int			ret_val;

	argc	= 0;
	argv	= NULL;
	ret_val	= PLP_ERR;
	log_info("CORBA client init() started\n");
	_orb	= CORBA::ORB_init(argc, argv);
	if (CORBA::is_nil(_orb) == false) {
		log_debug("ORB_init() done, finding server: %s\n", server_name);
		server_obj	= find_server_object_by_name(_orb,
							CONST_CONTEXT_NAME__PLPBUS,
							CONST_CONTEXT_KIND__PLPBUS,
							server_name,
							CONST_CONTEXT_NAME__PLPBUS);
		if (CORBA::is_nil(server_obj) == false) {
			_server		= plpbus_orb::OrbServer::_narrow(server_obj);
			if (CORBA::is_nil(_server) == false) {
				log_info("CORBA service found: %s\n", server_name);
				ret_val	= PLP_OK;
			}
		}
		else {
			log_error("Could not find CORBA service: %s\n", server_name);
		}
	}
	else {
		log_error("Could not init CORBA client\n");
	}
	return ret_val;
}

int BusClient::add_client_listener(IClientListener *listener_param) {
	log_debug("started\n");
	if (_poa == NULL) {
		OrbClientImpl			*client_cb;
		PortableServer::ObjectId_var	oid;

		_poa		= create_poa(_orb);
		client_cb	= new OrbClientImpl(listener_param);
		oid		= _poa->activate_object(client_cb);
		_client		= client_cb->_this();
		client_cb->_remove_ref();
		_server->add_event_listener(_client, "event_message", CONST_DEFAULT_EVENT_INTERVAL);
	}
	log_debug("done\n");
	return 0;
}

int BusClient::send_message_and_request_response(const char *msg_req_param) {
	_server->send_message_and_request_response(_client, msg_req_param);
	return 0;
}

int BusClient::send_message_and_wait_response(const char *msg_req_param, char **msg_rsp_param) {
	CORBA::Long 	ret_val;
	char		*rsp;

	rsp		= _server->send_message_and_wait_response(msg_req_param, ret_val);
	*msg_rsp_param	= strdup(rsp);
	CORBA::string_free(rsp);
	return ret_val;
}

int BusClient::send_message_and_request_response(const BusMessage *msg_req_param) {
	DataItemSequence	*seq;

	seq	= (DataItemSequence *)msg_req_param->_dataItemSeq;
	_server->send_dataitem_message_and_request_response(_client, *seq);
	return 0;
}

int BusClient::send_message_and_wait_response(const BusMessage *msg_req_param, BusMessage **msg_rsp_param) {
	DataItemSequence	*seq_rsp;
	DataItemSequence	*seq;

	seq_rsp	= NULL;
	seq	= (DataItemSequence *)msg_req_param->_dataItemSeq;
	_server->send_dataitem_message_and_wait_response(*seq, seq_rsp);
	*msg_rsp_param	= new BusMessageInternal(*seq_rsp);
	delete(seq_rsp);
	return 0;
}

void BusClient::request_shutdown() {
	if (CORBA::is_nil(_server) == false) {
		_server->shutdown();
	}
}

PortableServer::POA_var BusClient::create_poa(CORBA::ORB_var orb) {
	PortableServer::POA_var 	ret_val;
	CORBA::Object_var		poa_obj;
	CORBA::PolicyList		policy_list;
	CORBA::Any			policyVal;
	PortableServer::POAManager_var	poa_man;
	PortableServer::POA_var 	rootpoa;

	ret_val = NULL;
	poa_obj	= orb->resolve_initial_references(CONST_ROOT_POA_NAME);
	if (poa_obj != NULL) {
		rootpoa	= PortableServer::POA::_narrow(poa_obj);
		if (rootpoa != NULL) {
			poa_man	= rootpoa->the_POAManager();
			if (poa_man != NULL) {
				poa_man->activate();
				// bidirectional policy
				policy_list.length(1);
				policyVal	<<= BiDirPolicy::BOTH;
				policy_list[0] = orb->create_policy(BiDirPolicy::BIDIRECTIONAL_POLICY_TYPE, policyVal);
				ret_val = rootpoa->create_POA(CONST_ROOT_POA_BIDIR_POLICY_NAME,
							poa_man,
							policy_list);
			}
		}
	}
	else {
		log_error("Failed to create RootPOA\n");
	}
	return ret_val;
}

CosNaming::NamingContext_var BusClient::get_name_service_context(CORBA::ORB_var orb_param,
								const char *nameservice_name_param) {
	CORBA::Object_var		ns_obj;
	CosNaming::NamingContext_var	ret_val;

	ret_val	= NULL;
	try {
		ns_obj	= orb_param->resolve_initial_references(nameservice_name_param);
		if (CORBA::is_nil(ns_obj) == false) {
			// narrow the object reference
			ret_val	= CosNaming::NamingContext::_narrow(ns_obj);
		}
	}
	catch (CORBA::ORB::InvalidName&) {
		// This should not happen!
		log_error("Could not find name service.\n");
	}
	catch(CORBA::TRANSIENT& ex) {
		log_error("Could not find name service, verify that name service is running.\n");
	}
	catch (CORBA::NO_RESOURCES&) {
		log_error("Could not find name service, verify that name service is running.\n");
	}
	catch(CORBA::SystemException& ex) {
		log_error("Could not find name service, unknown reason.\n");
	}
	return ret_val;
}

CORBA::Object_var BusClient::find_server_object_by_name(CORBA::ORB_var orb_param,
							const char *leaf_name_param,
							const char *leaf_kind_param,
							const char *service_name_param,
							const char *service_kind_param)
{
	CORBA::Object_var		ret_val;
	CosNaming::NamingContext_var	ns_root_context;
	CosNaming::Name			service_data;
	char *n;

	ret_val	= CORBA::Object::_nil();
	n	= strdup(CONST_NAME_SERVICE_NAME);
	ns_root_context = get_name_service_context(orb_param, n);
	free(n);
	if (CORBA::is_nil(ns_root_context) == false) {
		// define search criteria
		service_data.length(2);
		service_data[0].id   = leaf_name_param;
		service_data[0].kind = leaf_kind_param;
		service_data[1].id   = service_name_param;
		service_data[1].kind = service_kind_param;
		try {
			ret_val	= ns_root_context->resolve(service_data);
		}
		catch(CosNaming::NamingContext::NotFound& ex) {
			log_error("Could not find service from the name server.\n");
		}
		catch(CORBA::TRANSIENT& ex) {
			log_error("Could not find service from the name server.\n");
		}
		catch(CORBA::SystemException& ex) {
			log_error("Could not find service from the name server, unknown error.\n");
		}
	}
	else {
		log_error("Could not find naming service.\n");
	}
	return ret_val;
}