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

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

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

#include "log.h"
#include "Data.hh"
#include "Date.hh"

using namespace std;
using namespace plp;

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

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

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

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

Data::Data(vector<double> *vect_param) {
	unsigned int	ii;
	unsigned int	sz;

	sz	= vect_param->size();
	//log_debug("Data(), value count: %d\n", size);
	value_arr.resize(sz);
	for (ii = 0; ii < sz; ii++) {
		value_arr[ii]	= vect_param->at(ii);
		//log_debug("Data(), value[%d]: %f\n", ii, value_arr[ii]);
	}
}

Data::Data(vector<double> *vector_param, string unit_param) {
	unsigned int	ii;
	unsigned int	sz;

	sz	= vector_param->size();
	//log_debug("Data(), value count: %d\n", size);
	value_arr.resize(sz);
	for (ii = 0; ii < sz; ii++) {
		value_arr[ii]	= vector_param->at(ii);
		//log_debug("Data(), value[%d]: %f\n", ii, value_arr[ii]);
	}
	unit	= unit_param;
}

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

	size	= vector_param->size();
	//log_debug("Data(), value count: %d\n", size);
	value_arr.resize(size);
	for (ii = 0; ii < 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);
	unit	= unit_param;
}

Data::Data(valarray<double> *val_arr_param, Date *date_param) {
	unsigned int	ii;
	unsigned int	sz;

	sz	= val_arr_param->size();
	value_arr.resize(sz);
	for (ii = 0; ii < sz; ii++) {
		value_arr[ii]	= (*val_arr_param)[ii];
	}
	date_time.copy(date_param);
}

Data::~Data() {
}

Data *Data::clone() {
	Data	*ret_val;

	ret_val	= new Data(&value_arr, &date_time);
	return ret_val;
}

void Data::printout() {
	log_debug("  data: %s\n", to_string().c_str());
}

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

void Data::set_date(Date *date_param) {
	date_time.copy(date_param);
}

string Data::get_unit() {
	return unit;
}

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

	ii	= 0;
	ret_val	= NULL;
	//log_debug("parse_string: %s\n", dataline.c_str());
	while(getline(ss, item, '|')) {
		if (ii == 0) {
			// parse date
			date	= Date::parse_date_str(item);
		}
		else if (ii >= 1) {
			suc_flg	= string_to_number<double>(val, item, dec);
			if (suc_flg) {
				//log_debug("adding number: %f\n", val);
				v.push_back(val);
			}
		}
		ii++;
	}
	ii	= item.find_last_of(" ");
	sz	= item.size();
	if ((ii >= 0) &&
	    ((ii + 1) <= (sz - 1))) {
		unit	= item.substr(ii + 1);
	}
	else {
		unit	= "";
	}
	if (v.size() > 0) {
		ret_val	= new Data(&v, &date, unit);
	}
	return ret_val;
}

string Data::to_string(int dec_precision) {
	unsigned int 	ii;
	ostringstream	out;
	string		ret_val;

	ret_val	= date_time.to_string();
	if (value_arr.size() > 0) {
		for (ii = 0; ii < value_arr.size(); ii++) {
			out << "|" << fixed << setprecision(dec_precision) << value_arr[ii];
		}
		ret_val.append(out.str());
		if (unit.empty() == false) {
			ret_val.append(" ");
			ret_val.append(unit.c_str());
		}
	}
	return ret_val;
}

string Data::to_string() {
	return to_string(3);
}

int Data::get_value_count() {
	return value_arr.size();
}

double Data::get(int indx) {
	return value_arr[indx];
}

DataRange::DataRange() {
	val_matrix	= NULL;
	column_count	= 0;
	row_count	= 0;
	unit		= "";
}

DataRange::DataRange(Data *data) {
	val_matrix	= NULL;
	row_count	= 0;
	if (data != NULL) {
		column_count	= data->value_arr.size();
		unit		= data->get_unit();
		add(data);
	}
	else {
		column_count	= 0;
		unit		= "";
	}
}

DataRange::DataRange(DataRange *datarange) {
	val_matrix	= NULL;
	row_count	= 0;
	column_count	= 0;
	unit		= "";
	if (datarange != NULL) {
		add(datarange);
	}
}

DataRange::DataRange(int value_count_per_data_item, string unit_param) {
	val_matrix	= NULL;
	column_count	= value_count_per_data_item;
	row_count	= 0;
	unit		= unit_param;
}

DataRange::~DataRange() {
	unsigned 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) {
	int	ii;
	int	indx;
	Date	*date;
	int	cnt;

	if (data != NULL) {
		if ((val_matrix == NULL) &&
		    (column_count == 0) &&
		    (unit.empty() == true)) {
			column_count	= data->value_arr.size();
			unit		= data->get_unit();
		}
		cnt		= (row_count + 1) * column_count;
		val_matrix	= (double *)realloc(val_matrix, cnt * sizeof(double));
		indx		= row_count * column_count;
		cnt		= data->value_arr.size();
		if (cnt != column_count) {
			log_error("Error when adding data... Invalid data item count!\n");
			if (cnt > column_count) {
				cnt	= column_count;
			}
			else {
				for (ii = cnt; ii < column_count; ii++) {
					val_matrix[indx + ii]	= 0;
				}
			}
		}
		for (ii = 0; ii < cnt; 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().clone();
		date_list.push_back(date);
		row_count++;
	}
}

void DataRange::add(DataRange *datarange) {
	int	ii;
	int	cnt;
	Data	*dta;

	if (datarange != NULL) {
		cnt	= datarange->get_count();
		for (ii = 0; ii < cnt; ii++) {
			dta	= datarange->get(ii);
			add(dta);
			delete(dta);
		}
	}
}

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

	ret_val	= NULL;
	if ((row_index >= 0) &&
	    (row_index < row_count)) {
		start_indx	= row_index * column_count;
		for (ii = 0; ii < column_count; ii++) {
			//val	= val_matrix[0];
			val	= val_matrix[start_indx + ii];
			//log_debug("val[%d] = %f\n", (start_indx + ii), val);
			vect.push_back(val);
		}
		date	= date_list.at(row_index);
		ret_val	= new Data(&vect, date, unit);
	}
	return ret_val;
}

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

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

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

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

Data *DataRange::get_last() {
	return get(row_count - 1);
}

void DataRange::printout() {
	int	ii;
	Data	*data;

	log_debug("---- DataRange, number of data items: %d\n ----", row_count);
	for (ii = 0; ii < row_count; ii++) {
		data	= get(ii);
		if (data != NULL) {
			data->printout();
			delete(data);
		}
	}
	log_debug("---- DataRange printout done ----\n");
}