/*
 * DataRange.cc
 *
 *  Created on: Dec 7, 2010
 *      Author: lamikr
 */

#include <string>
#include <iostream>
#include <sstream>

#include <stdio.h>
#include <time.h>
#include <malloc.h>

#include <plp/log.h>

#include "Data.hh"
#include "W1Util.hh"

using namespace std;
using namespace plp;
using namespace w1;

template <class NumberDataType>
bool string_to_number(NumberDataType& result,
                 const std::string& string_param,
                 std::ios_base& (*format)(std::ios_base&))
{
	std::istringstream iss(string_param);
	return !(iss >> format >> result).fail();
}

Data::Data(int size) {
	value_arr.resize(size);
}

Data::Data(int size, double default_value) {
	int ii;

	value_arr.resize(size);
	for (ii = 0; ii < size; ii++) {
		value_arr[ii]	= default_value;
	}
}

Data::Data(vector<double> vector_param, Date *date_param) {
	int	ii;
	int	size;

	size	= vector_param.size();
	//log_debug("Data(), value count: %d\n", size);
	value_arr.resize(size);
	for (int ii = 0; ii < vector_param.size(); ii++) {
		value_arr[ii]	= vector_param.at(ii);
		//log_debug("Data(), value[%d]: %f\n", ii, value_arr[ii]);
	}
	date_time.copy(date_param);
}

Data::Data(std::valarray<double> value_arr_param, Date *date_param) {
	value_arr.resize(value_arr_param.size());
	for (int ii = 0; ii < value_arr_param.size(); ii++) {
		value_arr[ii]	= value_arr_param[ii];
	}
	date_time.copy(date_param);
}

Data::~Data() {
}

plp::Date Data::get_date() {
	return date_time;
}

void Data::set_date(plp::Date date) {
	date_time.copy(&date);
}

void Data::printout() {
	int	ii;

	date_time.printout();
	for (ii = 0; ii < value_arr.size(); ii++) {
		log_debug("  data[%d] = %f\n", ii, value_arr[ii]);
	}
}

Data *Data::parse_data_string(const string& dataline) {
	stringstream	ss(dataline);
	string		item;
	double		val;
	Data		*ret_val;
	int		ii;
	bool		suc_flg;
	vector<double>	v;
	Date		date;

	ii	= 0;
	while(getline(ss, item, '|')) {
		if (ii == 0) {
			// parse date
			date	= W1Util::parse_date_str(item);
		}
		// skip the device type and device id fields
		// TODO: store device type and id to own file
		else if (ii >= 3) {
			suc_flg	= string_to_number<double>(val, item, dec);
			if (suc_flg) {
				//log_debug("adding number: %f\n", val);
				v.push_back(val);
			}
		}
		ii++;
	}
	ret_val	= new Data(v, &date);
	return ret_val;
}

DataRange::DataRange(int value_count_per_data_item) {
	val_matrix	= NULL;
	column_count	= value_count_per_data_item;
	row_count	= 0;
}

DataRange::DataRange(Data data) {
	val_matrix	= NULL;
	column_count	= data.value_arr.size();
	row_count	= 0;
	add_data(data);
}

DataRange::~DataRange() {
	int	ii;
	Date	*date;

	if (val_matrix != NULL) {
		free(val_matrix);
		val_matrix	= NULL;
	}
	for (ii = 0; ii < date_list.size(); ii++) {
		date	= date_list.at(ii);
		delete(date);
	}
}

void DataRange::add_data(Data data) {
	int			ii;
	int			r_count;
	int			indx;
	Date			date;

	//log_debug("old row_count: %d, column_count: %d, value_arr_size: %d\n", row_count, column_count, data.value_arr.size());
	val_matrix	= (double *)realloc(val_matrix, ((row_count + 1) * column_count) * sizeof(double));
	indx		= row_count * column_count;
	for (ii = 0; ii < data.value_arr.size(); ii++) {
		val_matrix[indx + ii]	= data.value_arr[ii];
	}
/*
	for (int ii = 0; ii < ((row_count + 1) * column_count); ii++) {
		log_debug("data_matrix[%d] = %f\n", ii, val_matrix[ii]);
	}
*/
	date	= data.get_date();
	date_list.push_back(date.clone());
	row_count++;
}

Data *DataRange::get_data(int row_index) {
	Data		*ret_val;
	int		start_indx;
	int		ii;
	vector<double>	vector;
	Date		*date;

	ret_val	= NULL;
	if ((row_index >= 0) &&
	    (row_index < row_count)) {
		start_indx	= row_index * column_count;
		for (ii = 0; ii < column_count; ii++) {
			vector.push_back(val_matrix[start_indx + ii]);
		}
		date	= date_list.at(row_index);
		ret_val	= new Data(vector, date);
	}
	return ret_val;
}

int DataRange::get_data_row_count() {
	return row_count;
}

int DataRange::get_data_column_count() {
	return column_count;
}

Data *DataRange::get_first_data() {
	Data	*ret_val;

	ret_val	= NULL;
	if (row_count > 0) {
		ret_val	= get_data(0);
	}
	return ret_val;
}

Data *DataRange::get_last_data() {
	return get_data(row_count - 1);
}