/*
 * DeviceManager.cc
 *
 *  Created on: Mar 3, 2011
 *      Author: lamikr
 */
#include <sstream>
#include <typeinfo>
#include <unistd.h>

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

#include <plp/Data.hh>
#include <plp/Device.hh>
#include <plp/SensorDevice.hh>
#include <plp/DeviceConfig.hh>

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

using namespace plpdevicebus;

static void *device_data_reader_thread(void *thread_args_pointer) {
	list<Device *>			*_dev_lst;
	list<Device *>::iterator	list_iter;
	Device				*device;
	SensorDevice			*sensor;
	long				read_int_sec;
	plp::Data			*data;

	read_int_sec	= DeviceConfig::get_read_interval_seconds();
	if (read_int_sec < 0)
		read_int_sec = 600;
	_dev_lst	= (list<Device *> *)thread_args_pointer;
	while(1) {
		for (list_iter = _dev_lst->begin(); list_iter != _dev_lst->end(); list_iter++) {
			device	= (Device *)*list_iter;
			sensor = dynamic_cast<SensorDevice *>(device);
			if (sensor != NULL) {
				data = sensor->get_data();
				if (data != NULL)
					delete(data);
			}
		}
		sleep(read_int_sec);
	}
	pthread_exit(NULL);
}

DeviceManagerServer::DeviceManagerServer(list<Device *> dev_lst_param) {
	//DeviceConfig::set_base_dir_name(storage_dir_param);
	//_dev_lst	= Factory::get_device_list();
	_dev_lst	= dev_lst_param;
	/* In some toolchains the size is not unsigned int instead of long
           unsigned int, and that can cause warnings/errors without typecasting
         */
	log_info("device count: %lu\n", (long unsigned int)_dev_lst.size());
	_lstnr_thrd	= 0;
	pthread_create(&_lstnr_thrd,
			NULL,
			device_data_reader_thread,
			(void *)&_dev_lst);
}

DeviceManagerServer::~DeviceManagerServer() {
}

void decode_device_to_busmessage(const BusMessage *ret_val,
				Device *device,
				int indx) {
	ostringstream 	key;
	SensorDevice	*sensor;
	Data		*data;
	string		data_str;

	if ((ret_val != NULL) &&
	    (device != NULL)) {
		key.str("");
		key << RSP__DEVICE_LIST__ID << indx;
		((BusMessage *)ret_val)->add_string_parameter(key.str(), device->get_id());

		key.str("");
		key << RSP__DEVICE_LIST__NAME << indx;
		((BusMessage *)ret_val)->add_string_parameter(key.str(), device->get_name());

		key.str("");
		key << RSP__DEVICE_LIST__TYPE << indx;
		((BusMessage *)ret_val)->add_string_parameter(key.str(), device->get_type());

		key.str("");
		key << RSP__DEVICE_LIST__LF_STATE << indx;
		((BusMessage *)ret_val)->add_int_parameter(key.str(), device->get_lifecycle_state());
		sensor = dynamic_cast<SensorDevice *>(device);
		if (sensor != NULL) {
			key.str("");
			key << RSP__DEVICE_LIST__DATA << indx;
			data	= sensor->get_data();
			if (data != NULL) {
				data_str	= data->to_string();
				log_debug("returning data: %s\n", data_str.c_str());
				((BusMessage *)ret_val)->add_string_parameter(key.str(), data_str);
				delete(data);
			}
		}
	}
}

void DeviceManagerServer::get_device_list(const BusMessage *ret_val) {
	list<Device *>::iterator	list_iter;
	Device				*device;
	int				indx;

	indx	= 0;
	((BusMessage *)ret_val)->add_int_parameter(RSP__DEVICE_LIST__DEVICE_COUNT, _dev_lst.size());
	for (list_iter = _dev_lst.begin(); list_iter != _dev_lst.end(); list_iter++) {
		device	= (Device *)*list_iter;
		decode_device_to_busmessage(ret_val,
					device,
					indx);
		indx++;
	}
}

const Device *DeviceManagerServer::get_device_by_id(string id_param) {
	Device			*ret_val;
	Device			*device;
	list<Device *>::iterator list_iter;

	ret_val	= NULL;
	for(list_iter = _dev_lst.begin(); list_iter != _dev_lst.end(); list_iter++) {
		device	= (Device *)*list_iter;
		if (device != NULL) {
			if (device->get_id().compare(id_param) == 0) {
				ret_val	= device;
				break;
			}
		}
	}
	return ret_val;
}

static void add_data_values_to_bus_message(const BusMessage *msg_rsp_param,
					Data *data,
					string key_name_base_param) {
	string val_str;

	val_str	= data->to_string();
	((BusMessage *)msg_rsp_param)->add_string_parameter(key_name_base_param, val_str);
}

void decode_latest_data_to_busmessage(const BusMessage *ret_val,
			const DataReader *reader) {
	DataRange	*dr;
	Data 		*data;

	data	= ((DataReader *)reader)->get_latest_data();
	if (data != NULL) {
		add_data_values_to_bus_message(ret_val,
					data,
					RSP__LATEST_DATA_VALUE);
		//((BusMessage *)ret_val)->printout();
		delete(data);
	}
	dr	= ((DataReader *)reader)->get_daily_summary(MIN);
	if (dr != NULL) {
		if (dr->get_count() > 0) {
			data	= dr->get_first();;
			add_data_values_to_bus_message(ret_val,
					data,
					RSP__MIN_DATA_VALUE);
			delete(data);
		}
		delete(dr);
	}
	dr	= ((DataReader *)reader)->get_daily_summary(MAX);
	if (dr != NULL) {
		if (dr->get_count() > 0) {
			data	= dr->get_first();
			add_data_values_to_bus_message(ret_val,
						data,
						RSP__MAX_DATA_VALUE);
			delete(data);
		}
		delete(dr);
	}
}

void decode_first_and_last_data_to_busmessage(const BusMessage *ret_val,
						DataRange *dr) {
	Data	*data;

	data	= dr->get_first();
	if (data != NULL) {
		add_data_values_to_bus_message(ret_val,
					data,
					RSP__FIRST_DATA_VALUE);
		//((BusMessage *)ret_val)->printout();
		delete(data);
	}
	data	= dr->get_last();
	if (data != NULL) {
		add_data_values_to_bus_message(ret_val,
					data,
					RSP__LATEST_DATA_VALUE);
		//((BusMessage *)ret_val)->printout();
		delete(data);
	}
}

void decode_data_range_to_busmessage(const BusMessage *ret_val,
				DataRange *dr) {
	Data		*data;
	int		ii;
	int		count;
	ostringstream 	key;

	count	= dr->get_count();
	((BusMessage *)ret_val)->add_int_parameter(RSP__COUNT, count);
	for (ii = 0; ii < count; ii++) {
		data	= dr->get(ii);
		if (data != NULL) {
			key.str("");
			key << RSP__DATA_VALUE << ii;
			add_data_values_to_bus_message(ret_val,
						data,
						key.str());
			delete(data);
		}
	}
}

void DeviceManagerServer::get_latest_data(BusMessage *msg_req_param,
					const BusMessage *ret_val) {
	string			id;
	int			err_flg;
	Device			*dev;
	SensorDevice		*sensor;
	ostringstream 		key;
	const DataReader	*reader;

	id	= msg_req_param->get_string_parameter(REQ__DEVICE_ID, &err_flg);
	if (err_flg == PLP_OK) {
		dev	= (Device *)get_device_by_id(id);
		if (dev != NULL) {
			sensor	= dynamic_cast<SensorDevice *>(dev);
			if (sensor != NULL) {
				reader	= sensor->get_datareader();
				decode_latest_data_to_busmessage(ret_val, reader);
			}
		}
	}
}

void DeviceManagerServer::get_data_range(BusMessage *msg_req_param,
					const BusMessage *ret_val) {
	string			id;
	int			err_flg;
	Device			*dev;
	SensorDevice		*sensor;
	ostringstream 		key;
	const DataReader	*reader;
	DataRange		*dr;

	id	= msg_req_param->get_string_parameter(REQ__DEVICE_ID, &err_flg);
	if (err_flg == PLP_OK) {
		dev	= (Device *)get_device_by_id(id);
		if (dev != NULL) {
			sensor	= dynamic_cast<SensorDevice *>(dev);
			if (sensor != NULL) {
				reader	= sensor->get_datareader();
				if (reader != NULL) {
					dr	= ((DataReader *)reader)->get_data_range();
					if (dr != NULL) {
						decode_first_and_last_data_to_busmessage(ret_val, dr);
						delete(dr);
					}
				}
			}
		}
	}
}

void DeviceManagerServer::get_data_between_dates(BusMessage *msg_req_param,
					const BusMessage *ret_val) {
	string			id;
	int			err_flg;
	Device			*dev;
	SensorDevice		*sensor;
	ostringstream 		key;
	const DataReader	*reader;
	DataRange		*dr;
	string			startdate_str;
	string			enddate_str;
	Date			sdate;
	Date			edate;

	log_debug("started\n");
	id		= msg_req_param->get_string_parameter(REQ__DEVICE_ID, &err_flg);
	if (err_flg == PLP_OK)
		startdate_str	= msg_req_param->get_string_parameter(REQ__DATE1, &err_flg);
	if (err_flg == PLP_OK)
		enddate_str	= msg_req_param->get_string_parameter(REQ__DATE2, &err_flg);
	log_debug("id: %s, sdate: %s, edate: %s\n", id.c_str(), startdate_str.c_str(), enddate_str.c_str());
	if (err_flg == PLP_OK) {
		sdate	= Date::parse_date_str(startdate_str);
		edate	= Date::parse_date_str(enddate_str);
		log_debug("id: %s, sdate: %s, edate: %s\n", id.c_str(), startdate_str.c_str(), enddate_str.c_str());
		dev	= (Device *)get_device_by_id(id);
		if (dev != NULL) {
			sensor	= dynamic_cast<SensorDevice *>(dev);
			if (sensor != NULL) {
				reader	= sensor->get_datareader();
				if (reader != NULL) {
					dr	= ((DataReader *)reader)->get_data(&sdate, &edate);
					log_debug("dr.size: %d\n", dr->get_count());
					if (dr != NULL) {
						decode_data_range_to_busmessage(ret_val, dr);
						delete(dr);
					}
				}
			}
		}
	}
	else {
		log_error("Invalid request parameters.\n");
	}
}