/*
 * BusMessage.cpp
 *
 *  Created on: Aug 17, 2010
 *      Author: lamikr
 */

#include <malloc.h>
#include <omniORB4/CORBA.h>

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

#include "BusMessage.hh"
#include "RequestResponseBus.hh"

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

#define CONST_MSG_ID_KEY_NAME	"_msgtype"

BusMessage::BusMessage() {
	_dataItemSeq	= new DataItemSequence(0);
}

BusMessage::BusMessage(long type_param) {
	_dataItemSeq	= new DataItemSequence(0);

	add_long_parameter(CONST_MSG_ID_KEY_NAME, type_param);
}

BusMessage::BusMessage(long type_param,
			const char *arg_name_param,
			const char *arg_string_value_param) {
	_dataItemSeq	= new DataItemSequence(0);
	add_long_parameter(CONST_MSG_ID_KEY_NAME, type_param);
	add_string_parameter(arg_name_param, arg_string_value_param);
}

BusMessage::~BusMessage() {
}

int BusMessage::add_string_parameter(string arg_name_param, string value_param)
{
	long			length;
	int			ret_val;
	DataItem		*item;
	DataItemSequence	*seq;

	ret_val	= 0;
	seq	= (DataItemSequence *)_dataItemSeq;
	if (arg_name_param.empty() == false) {
		length		= seq->length();
		item		= new DataItem();
		item->name	= strdup(arg_name_param.c_str());
		item->value	<<= strdup(value_param.c_str());
		seq->length(length + 1);
		(*seq)[length]	= *item;
	}
	else {
		ret_val	= -1;
	}
	return ret_val;
}

int BusMessage::add_long_parameter(const char *arg_name_param, long value_param)
{
	long			length;
	int			ret_val;
	DataItem		*item;
	DataItemSequence	*seq;

	ret_val	= 0;
	seq	= (DataItemSequence *)_dataItemSeq;
	if (arg_name_param != NULL) {
		length		= seq->length();
		item		= new DataItem();
		item->name	= strdup(arg_name_param);
		item->value	<<= value_param;

		seq->length(length + 1);
		(*seq)[length]	= *item;
	}
	else {
		ret_val	= -1;
	}
	return ret_val;
}

int BusMessage::add_int_parameter(string arg_name_param, int value_param)
{
	long			length;
	int			ret_val;
	DataItem		*item;
	DataItemSequence	*seq;

	ret_val	= 0;
	seq	= (DataItemSequence *)_dataItemSeq;
	if (arg_name_param.empty() == false) {
		length		= seq->length();
		item		= new DataItem();
		item->name	= strdup(arg_name_param.c_str());
		item->value	<<= (long)value_param;

		seq->length(length + 1);
		(*seq)[length]	= *item;
	}
	else {
		ret_val	= -1;
	}
	return ret_val;
}

int BusMessage::add_double_parameter(const char *arg_name_param, double value_param)
{
	long			length;
	int			ret_val;
	DataItem		*item;
	DataItemSequence	*seq;

	ret_val	= 0;
	log_debug("add_double_parameter() started\n");
	seq	= (DataItemSequence *)_dataItemSeq;
	if (arg_name_param != NULL) {
		length		= seq->length();
		item		= new DataItem();
		item->name	= strdup(arg_name_param);
		item->value	<<= (long)value_param;

		seq->length(length + 1);
		(*seq)[length]	= *item;
	}
	else {
		ret_val	= -1;
	}
	log_debug("add_double_parameter() done\n");
	return ret_val;
}

int BusMessage::add_float_parameter(const char *arg_name_param, float value_param)
{
	long			length;
	int			ret_val;
	DataItem		*item;
	DataItemSequence	*seq;

	ret_val	= 0;
	seq	= (DataItemSequence *)_dataItemSeq;
	if (arg_name_param != NULL) {
		length		= seq->length();
		item		= new DataItem();
		item->name	= strdup(arg_name_param);
		item->value	<<= (long)value_param;

		seq->length(length + 1);
		(*seq)[length]	= *item;
	}
	else {
		ret_val	= -1;
	}
	return ret_val;
}

static DataItem *get_dataitem_by_param_name(DataItemSequence *seq, string arg_name_param) {
	DataItem	*ret_val;
	long int 	count;
	DataItem	*item;
	const char	*item_name;

	ret_val	= NULL;
	count	= seq->length();
	for (long ii = 0; ii < count; ii++) {
		item		= &(*seq)[ii];
		item_name	= item->name;
		if (strcmp(arg_name_param.c_str(), item_name) == 0) {
			ret_val	= item;
			break;
		}
	}
	return ret_val;
}

long BusMessage::get_type(int *err_flg) {
	long	ret_val;
	long	res;

	res	= get_long_parameter(CONST_MSG_ID_KEY_NAME, err_flg);
	if (*err_flg == PLP_OK) {
		ret_val	= res;
	}
	return ret_val;
}

string BusMessage::get_string_parameter(string arg_name_param, int *err_flg) {
	string			ret_val;
	DataItem		*item;
	DataItemSequence	*seq;
	const char		*ch;

	*err_flg	= PLP_ERR_DATA_NOT_FOUND;
	seq		= (DataItemSequence *)_dataItemSeq;
	item		= get_dataitem_by_param_name(seq, arg_name_param);
	if (item != NULL) {
		item->value >>= CORBA::Any::to_string(ch, 0);
		ret_val		= ch;
		*err_flg	= PLP_OK;
	}
	return ret_val;
}

long BusMessage::get_long_parameter(string arg_name_param, int *err_flg) {
	long			ret_val;
	DataItem		*item;
	DataItemSequence	*seq;

	*err_flg	= PLP_ERR_DATA_NOT_FOUND;
	seq		= (DataItemSequence *)_dataItemSeq;
	item		= get_dataitem_by_param_name(seq, arg_name_param);
	if (item != NULL) {
		item->value >>= ret_val;
		*err_flg	= PLP_OK;
	}
	return ret_val;
}

int BusMessage::get_int_parameter(string arg_name_param, int *err_flg) {
	int			ret_val;
	DataItem		*item;
	DataItemSequence	*seq;
	long			tmp;

	*err_flg	= PLP_ERR_DATA_NOT_FOUND;
	seq		= (DataItemSequence *)_dataItemSeq;
	item		= get_dataitem_by_param_name(seq, arg_name_param);
	if (item != NULL) {
		item->value >>= tmp;
		ret_val	=	 (int)tmp;
		*err_flg	= PLP_OK;
	}
	return ret_val;
}

double BusMessage::get_double_parameter(string arg_name_param, int *err_flg) {
	double		ret_val;
	DataItem	*item;
	DataItemSequence *seq;

	*err_flg	= PLP_ERR_DATA_NOT_FOUND;
	seq		= (DataItemSequence *)_dataItemSeq;
	item		= get_dataitem_by_param_name(seq, arg_name_param);
	if (item != NULL) {
		item->value >>= ret_val;
		*err_flg	= PLP_OK;
	}
	return ret_val;
}

float BusMessage::get_float_parameter(string arg_name_param, int *err_flg) {
	float		ret_val;
	DataItem	*item;
	DataItemSequence *seq;

	*err_flg	= PLP_ERR_DATA_NOT_FOUND;
	seq		= (DataItemSequence *)_dataItemSeq;
	item		= get_dataitem_by_param_name(seq, arg_name_param);
	if (item != NULL) {
		item->value >>= ret_val;
		*err_flg	= PLP_OK;
	}
	return ret_val;
}

void BusMessage::printout_dataitem(long index, void *item) {
	CORBA::TCKind	kind;
	const char 	*name;
	DataItem	*dataitem;

	dataitem	= (DataItem *)item;
	if (item != NULL) {
		if (dataitem->name != NULL) {
			name	= dataitem->name;
			kind	= dataitem->value.type()->kind();
			switch(kind) {
				case tk_string:
					{
						const char *val;

						dataitem->value >>= val;
						log_debug("\t[%ld] %s: %s\n", index, name, val);
					}
					break;
				case tk_long:
					{
						long	val;
						dataitem->value >>= val;
						log_debug("\t[%ld] %s: %ld\n", index, name, val);
						//val_str	= strdup("long");
					}
					break;
				case tk_double:
					{
						double val;
						dataitem->value >>= val;
						log_debug("\t[%ld] %s: %f\n", index, name, val);
						//val_str	= strdup("double");
					}
					break;
				case tk_float:
					{
						float val;
						dataitem->value >>= val;
						log_debug("\t[l%ld] %s: %f\n", index, name, val);
						//val_str	= strdup("float");
					}
					break;
				default:
					log_error("\t[%ld], name: %s, value unknown\n", index, name);
			}
		}
		else {
			log_error("\t[%ld] Invalid data item name name or value\n", index);
		}
	}
	else {
		log_error("\t[%ld] dataItem NULL.", index);
	}
}

void BusMessage::printout() {
	long int 		count;
	DataItem		item;
	DataItemSequence	*seq;

	seq	= (DataItemSequence *)_dataItemSeq;
	count	= seq->length();
	log_debug("BusMessage.printout(): parameter count: %ld\n", count);
	for (long ii = 0; ii < count; ii++) {
		item	= (*seq)[ii];
		printout_dataitem(ii, &item);
	}
	log_debug("BusMessage.printout() done\n");;
}