/*
 * DeviceManagerClient.cc
 *
 *  Created on: Mar 4, 2011
 *      Author: lamikr
 */
#include <sstream>
#include <string>

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

#include <plp/Data.hh>
#include <plp/DeviceData.hh>

#include "DeviceManagerClient.hh"
#include "../src/plp/devicebus/DeviceBusMessageId.hh"

using namespace std;
using namespace plp;
using namespace plpbus;
using namespace plpdevicebus;

DeviceManagerClient::DeviceManagerClient() {
	_device_list	= NULL;
}

static void clean_device_list(list<Device *> *dev_lst) {
	Device	*dev;

	if (dev_lst != NULL) {
		while (dev_lst->empty() == false) {
			dev	= dev_lst->back();
			dev_lst->pop_back();
			delete(dev);
		}
		delete(dev_lst);
		dev_lst	= NULL;
	}
}

DeviceManagerClient::~DeviceManagerClient() {
	clean_device_list(_device_list);
}

list<Device *> *DeviceManagerClient::parse_device_list_msg(BusMessage *msg_param,
							int *err_flg) {
	int				ii;
	long				count;
	ostringstream 			key;
	string				id;
	string				name;
	string				type;
	string				datastr;
	EnumDeviceLifeCycleStatus	state;
	int				state_i;
	Device				*dev;
	Data				*data;
	list<Device *>			*ret_val;

	ret_val	= new list<Device *>;
	count	= msg_param->get_long_parameter(RSP__DEVICE_LIST__DEVICE_COUNT, err_flg);
	log_debug("device count: %ld\n", count);
	if (*err_flg == PLP_OK) {
		for (ii = 0; ii < count; ii++) {
			data	= NULL;

			key.str("");
			key << RSP__DEVICE_LIST__ID << ii;
			id	= msg_param->get_string_parameter(key.str(), err_flg);
			if (*err_flg != PLP_OK) {
				log_error("Failed to parse device id.\n");
				break;
			}

			key.str("");
			key << RSP__DEVICE_LIST__NAME << ii;
			name	= msg_param->get_string_parameter(key.str(), err_flg);
			if (*err_flg != PLP_OK) {
				log_error("Failed to parse name for the device: %s\n", id.c_str());
				break;
			}

			key.str("");
			key << RSP__DEVICE_LIST__TYPE << ii;
			type	= msg_param->get_string_parameter(key.str(), err_flg);
			if (*err_flg != PLP_OK) {
				log_error("Failed to parse type for the device: %s\n", id.c_str());
				break;
			}

			key.str("");
			key << RSP__DEVICE_LIST__LF_STATE << ii;
			state_i	= msg_param->get_int_parameter(key.str(), err_flg);
			if (*err_flg != PLP_OK) {
				log_error("Failed to parse life cycle state for the device: %s\n", id.c_str());
				break;
			}
			state	= (EnumDeviceLifeCycleStatus)state_i;

			key.str("");
			key << RSP__DEVICE_LIST__DATA << ii;
			datastr	= msg_param->get_string_parameter(key.str(), err_flg);
			if (*err_flg == PLP_OK) {
				data	= Data::parse_string(datastr);
				if (data == NULL) {
					log_error("No data available for the device: %s\n", id.c_str());
				}
			}
			else {
				log_error("No data available for the device: %s\n", id.c_str());
			}
			dev	= new DeviceData(id, type, name, state, data);
			ret_val->push_back(dev);
		}
	}
	return ret_val;
}

const std::list<plp::Device *> *DeviceManagerClient::get_device_list(BusClient *client_param,
								int *err_flg) {
	BusMessage	*msg_req;
	BusMessage	*msg_rsp;

	msg_rsp	= NULL;
	msg_req	= new BusMessage(MSG_TYPE_ID__GET_DEVICE_LIST);
	client_param->send_message_and_wait_response(msg_req, &msg_rsp);
	clean_device_list(_device_list);
	_device_list	= parse_device_list_msg(msg_rsp, err_flg);
	delete(msg_req);
	delete(msg_rsp);

	return _device_list;
}

void DeviceManagerClient::parse_device_data_msg(BusMessage *msg_param,
					DataRange *result,
					string key_str,
					int *err_flg,
					string description) {
	string		data_str;
	Data		*data;

	*err_flg	= PLP_ERR;
	data		= NULL;
	if ((msg_param != NULL) &&
	    (result != NULL)) {
		data_str	= msg_param->get_string_parameter(key_str, err_flg);
		if (data_str.empty() == false) {
			data	= Data::parse_string(data_str);
		}
		if (data != NULL) {
			result->add(data);
			//log_debug("%s\n", description.c_str());
			data->printout();
			delete(data);
		}
	}
}

DataRange *DeviceManagerClient::parse_device_data_msg(BusMessage *msg_param,
						int *err_flg) {
	DataRange	*ret_val;

	*err_flg	= PLP_ERR;
	ret_val		= NULL;
	if (msg_param != NULL) {
		ret_val		= new DataRange();
		parse_device_data_msg(msg_param, ret_val, RSP__LATEST_DATA_VALUE, err_flg, "latest data");
		parse_device_data_msg(msg_param, ret_val, RSP__MIN_DATA_VALUE, err_flg, "latest min data value");
		parse_device_data_msg(msg_param, ret_val, RSP__MAX_DATA_VALUE, err_flg, "latest max data value");

		*err_flg	= PLP_OK;
	}
	return ret_val;
}

Data *DeviceManagerClient::get_latest_data(BusClient *client_param,
					string device_id_param,
					int *err_flg) {
	BusMessage	*msg_req;
	BusMessage	*msg_rsp;
	Data		*ret_val;
	DataRange	*dr;

	msg_rsp	= NULL;
	ret_val	= NULL;
	msg_req	= new BusMessage(MSG_TYPE_ID__GET_LATEST_DATA);
	msg_req->add_string_parameter(REQ__DEVICE_ID, device_id_param.c_str());
	client_param->send_message_and_wait_response(msg_req, &msg_rsp);
	dr	= parse_device_data_msg(msg_rsp, err_flg);
	ret_val	= dr->get_first();
	delete(dr);
	delete(msg_req);
	delete(msg_rsp);

	return ret_val;
}

DataRange *DeviceManagerClient::parse_first_and_last_data_msg(BusMessage *msg_param,
						int *err_flg) {
	DataRange	*ret_val;

	*err_flg	= PLP_ERR;
	ret_val		= NULL;
	if (msg_param != NULL) {
		ret_val		= new DataRange();
		parse_device_data_msg(msg_param, ret_val, RSP__FIRST_DATA_VALUE, err_flg, "first data");
		parse_device_data_msg(msg_param, ret_val, RSP__LATEST_DATA_VALUE, err_flg, "latest data");
		*err_flg	= PLP_OK;
	}
	return ret_val;
}

DataRange *DeviceManagerClient::parse_data_range_msg(BusMessage *msg_param,
						int *err_flg) {
	DataRange	*ret_val;
	int		ii;
	int		count;
	string		data_str;
	string		key_str;
	string		desc_str;
	ostringstream 	key;
	ostringstream 	desc;

	*err_flg	= PLP_ERR;
	ret_val		= NULL;
	if (msg_param != NULL) {
		ret_val		= new DataRange();
		count	= msg_param->get_int_parameter(RSP__COUNT, err_flg);
		//unit	= msg_param->get_string_parameter(RSP__DATA_UNIT, err_flg);
		for (ii = 0; ii < count; ii++) {
			key.str("");
			key << RSP__DATA_VALUE << ii;
			desc.str("");
			desc << "value_" << ii;
			parse_device_data_msg(msg_param,
					ret_val,
					key.str(),
					err_flg,
					desc.str());
		}
		*err_flg	= PLP_OK;
	}
	return ret_val;
}

DataRange *DeviceManagerClient::get_data_range(BusClient *client_param,
					string device_id_param,
					int *err_flg) {
	BusMessage	*msg_req;
	BusMessage	*msg_rsp;
	DataRange	*ret_val;

	msg_rsp	= NULL;
	ret_val	= NULL;
	msg_req	= new BusMessage(MSG_TYPE_ID__GET_DATA_RANGE);
	msg_req->add_string_parameter(REQ__DEVICE_ID, device_id_param);
	client_param->send_message_and_wait_response(msg_req, &msg_rsp);
	ret_val	= parse_first_and_last_data_msg(msg_rsp, err_flg);
	delete(msg_req);
	delete(msg_rsp);

	return ret_val;
}

DataRange *DeviceManagerClient::get_data(BusClient *client_param,
					string device_id_param,
					Date *start_date,
					Date *end_date,
					int *err_flg) {
	BusMessage	*msg_req;
	BusMessage	*msg_rsp;
	DataRange	*ret_val;

	msg_rsp	= NULL;
	ret_val	= NULL;
	msg_req	= new BusMessage(MSG_TYPE_ID__GET_DATA_BETWEEN_DATES);
	msg_req->add_string_parameter(REQ__DEVICE_ID, device_id_param);
	msg_req->add_string_parameter(REQ__DATE1, start_date->to_string());
	msg_req->add_string_parameter(REQ__DATE2, end_date->to_string());
	client_param->send_message_and_wait_response(msg_req, &msg_rsp);
	ret_val	= parse_data_range_msg(msg_rsp, err_flg);
	delete(msg_req);
	delete(msg_rsp);

	return ret_val;
}