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

#include <plp/log.h>

#include "BusClient.hh"
#include "BusMessageInternal.hh"

using namespace std;
using namespace plpbus;

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) {
			BusMessageInternal	*bus_msg;

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

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

BusClient::~BusClient()
{
	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;

	argc	= 0;
	argv	= NULL;
	log_info("init() started\n");;
	_orb	= CORBA::ORB_init(argc, argv);
	if (_orb != NULL) {
		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);
			log_info("Server object found: %s", server_name);
		}
		else {
			log_error("Could not find server object: %s\n", server_name);
		}
	}
	return 0;
}

int BusClient::add_client_listener(IClientListener *listener_param) {
	log_debug("add_client_listener() 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("add_client_listener() 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;

	*msg_rsp_param	= _server->send_message_and_wait_response(msg_req_param, ret_val);
	return ret_val;
}

int BusClient::send_message_and_request_response(BusMessage *msg_req_param) {
	_server->send_dataitem_message_and_request_response(_client, msg_req_param->_dataItemSeq);
	return 0;
}

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

	seq_rsp	= NULL;
	_server->send_dataitem_message_and_wait_response(msg_req_param->_dataItemSeq, 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 {
		cerr << "Failed to create RootPOA." << endl;
	}
	return ret_val;
}

CosNaming::NamingContext_var BusClient::get_name_service_context(CORBA::ORB_var orb_param) {
	CORBA::Object_var		ns_obj;
	CosNaming::NamingContext_var	ret_val;

	ret_val	= NULL;
	try {
		ns_obj	= orb_param->resolve_initial_references(CONST_NAME_SERVICE_NAME);
		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!
		cerr << "Could not find name service." << endl;
	}
	catch(CORBA::TRANSIENT& ex) {
		cerr << "Could not find name service, verify that name service is running. " << endl;
	}
	catch (CORBA::NO_RESOURCES&) {
		cerr << "Could not find name service, verify that name service is running. " << endl;
	}
	catch(CORBA::SystemException& ex) {
		cerr << "Could not find name service, unknown reason. " << endl;
	}
	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;

	ret_val		= CORBA::Object::_nil();
	ns_root_context = get_name_service_context(orb_param);
	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;
}