/*
 * DeviceData.cc
 *
 *  Created on: Nov 7, 2010
 *      Author: lamikr
 */
#include <dirent.h>
#include <malloc.h>
#include <errno.h>
#include <string.h>

#include "W1Util.hh"
#include "DeviceData.hh"
#include "W1Store.hh"
#include "DeviceConfig.hh"
#include "Factory.hh"

#include "plp/log.h"

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

DeviceData::DeviceData(string device_id_param) {
	string		base_dir;

	device_config		= Factory::get_device_config(device_id_param);
	summary_calc_type	= device_config->get_summary_calculation_type();
	device_id		= device_id_param;
	base_dir		= DeviceConfig::get_base_dir_name();
	device_dir		= W1Util::concat_paths(base_dir, device_id);
	device_ch_dir		= W1Util::concat_paths(base_dir, "cache");
	device_ch_dir		= W1Util::concat_paths(device_ch_dir, device_id);
}

DeviceData::~DeviceData() {
	delete(device_config);
}

Data *DeviceData::find_oldest_data(vector<string> year_vector) {
	unsigned int 	ii;
	string		year_dr;
	string		mon_dr;
	vector<string>	mon_vcr;
	vector<string>	d_vcr;
	string		f_name;
	W1Store		*store;
	Data		*ret_val;

	ret_val	= NULL;
	if (year_vector.size() > 0) {
		// dirs are alphabetically sorted
		year_dr	= year_vector.at(0);
		year_dr	= W1Util::concat_paths(device_dir, year_dr);
		mon_vcr	= W1Util::get_subdirectories(year_dr);
		for (ii = 0; ii < mon_vcr.size(); ii++) {
			mon_dr	= mon_vcr.at(ii);
			mon_dr	= W1Util::concat_paths(year_dr, mon_dr);
			// scan data files from month dir
			d_vcr	= W1Util::get_data_files(mon_dr);
			if (d_vcr.size() > 0) {
				f_name	= d_vcr.at(0);
				f_name	= W1Util::concat_paths(mon_dr, f_name);
				store	= new W1Store(f_name);
				ret_val	= store->get_oldest_data();
				delete(store);
				break;
			}
		}
	}
	return ret_val;
}

Data *DeviceData::find_newest_data(vector<string> year_vector) {
	int 		ii;
	string		year_dr;
	string		mon_dr;
	vector<string>	mon_vcr;
	vector<string>	d_vcr;
	string		f_name;
	Data		*ret_val;
	int		size;
	W1Store		*store;

	ret_val	= NULL;
	size	= year_vector.size();
	if (size > 0) {
		// dirs are alphabetically sorted
		year_dr	= year_vector.at(size - 1);
		year_dr	= W1Util::concat_paths(device_dir, year_dr);
		mon_vcr	= W1Util::get_subdirectories(year_dr);
		for (ii = mon_vcr.size() - 1; ii >= 0; ii--) {
			mon_dr	= mon_vcr.at(ii);
			mon_dr	= W1Util::concat_paths(year_dr, mon_dr);
			// scan data files from month dir
			d_vcr	= W1Util::get_data_files(mon_dr);
			size	= d_vcr.size();
			if (size > 0) {
				f_name	= d_vcr.at(size - 1);
				f_name	= W1Util::concat_paths(mon_dr, f_name);
				store	= new W1Store(f_name);
				ret_val	= store->get_newest_data();
				delete(store);
				break;
			}
		}
	}
	return ret_val;
}

DataRange *DeviceData::get_data_range() {
	DataRange	*ret_val;
	vector<string>	y_list;
	Data		*o_data;
	Data		*n_data;

	ret_val	= NULL;
	y_list	= W1Util::get_subdirectories(device_dir);
	o_data	= find_oldest_data(y_list);
	if (o_data != NULL) {
		n_data	= find_newest_data(y_list);
		if (n_data != NULL) {
			ret_val	= new DataRange(o_data);
			ret_val->add_data(n_data);
			delete(n_data);
		}
		delete(o_data);
	}
	return ret_val;
}

long int get_interval_type(Date *start_date,
			Date *end_date) {
	int	diff;
	int	ret_val;

	ret_val	= 0;
	diff	= end_date->year - start_date->year;
	if (diff != 0) {
		ret_val	= 0;
	}
	else {
		diff	= end_date->month - start_date->month;
		if (diff != 0) {
			ret_val	= 1;
		}
		else {
			diff	= end_date->day - start_date->day;
			if (diff != 0) {
				ret_val	= 2;
			}
			else {
				diff	= end_date->hour - start_date->hour;
				if (diff != 0) {
					ret_val	= 3;
				}
				else {
					diff	= end_date->min - start_date->min;
					if (diff != 0) {
						ret_val	= 4;
					}
					else {
						ret_val	= 5;
					}
				}
			}
		}
	}
	return ret_val;
}

Data *DeviceData::get_day_summary(Date *date) {
	Data	*ret_val;
	W1Store	*store;
	bool	suc_flg;

	ret_val	= NULL;
	store	= new W1Store(device_id, date);
	if (store != NULL) {
		suc_flg	= store->load();
		if (suc_flg == true) {
			switch(summary_calc_type) {
				case SUM:
					ret_val	= store->get_sum();
					break;
				case DELTA:
					ret_val	= store->get_delta();
					break;
				case MEAN:
				default:
					ret_val	= store->get_mean();
					break;
				case MAX:
					ret_val	= store->get_max();
					break;
				case MIN:
					ret_val	= store->get_min();
					break;
			}
			if (ret_val != NULL) {
				ret_val->printout();
			}
			else {
				log_error("Could not read data log for device: %s\n", device_id.c_str());
			}
		}
		else {
			log_error("Could not read data log for device: %s. Data file open load failed.\n", device_id.c_str());
		}
	}
	else {
		log_error("Could not read data log for device: %s\n", device_id.c_str());
	}
	delete(store);
	return ret_val;
}

DataRange *DeviceData::get_daily_summary(Date *start_date,
					Date *end_date) {
	DataRange	*ret_val;
	Data		*data;
	Date		*date;

	ret_val	= NULL;
	date	= start_date->clone();
	while(date->before(*end_date)) {
		data	= get_day_summary(date);
		if (data != NULL) {
			if (ret_val == NULL) {
				ret_val	= new DataRange(data);
			}
			else {
				ret_val->add_data(data);
			}
			delete(data);
		}
		date->tomorrow();
	}
	delete(date);
	return ret_val;
}

vector<Data *> DeviceData::get_hourly_summary(Date *date) {
	vector<Data *>	ret_val;
	W1Store	*	store;

	store	= new W1Store(device_id, date);
	store->load();
	switch(summary_calc_type) {
/*
		case SUM:
			ret_val	= store->get_sum();
			break;
*/
		case DELTA:
			ret_val	= store->get_delta(3600);
			break;
		case MEAN:
		default:
			ret_val	= store->get_mean(3600);
			break;
/*
		case MAX:
			ret_val	= store->get_max();
			break;
		case MIN:
			ret_val	= store->get_min();
			break;
*/
	}
	delete(store);
	return ret_val;
}

DataRange *DeviceData::get_hourly_summary(Date *start_date,
					Date *end_date) {
	DataRange			*ret_val;
	vector<Data *>			dta_list;
	Data				*data;
	Date				*date;
	vector<Data *>::iterator	iter;

	ret_val	= NULL;
	date	= start_date->clone();
	while(date->before(*end_date)) {
		dta_list	= get_hourly_summary(date);
		for(iter = dta_list.begin(); iter != dta_list.end(); iter++) {
			data	= (Data *)*iter;
			if (data != NULL) {
				if (ret_val == NULL) {
					ret_val	= new DataRange(data);
				}
				else {
					ret_val->add_data(data);
				}
				delete(data);
			}
		}
		date->tomorrow();
	}
	delete(date);
	return ret_val;
}
DataRange *DeviceData::get_data(Date *start_date,
				Date *end_date) {
	DataRange	*ret_val;
	int		int_type;

	ret_val		= NULL;
	start_date->printout();
	end_date->printout();
	int_type	= get_interval_type(start_date, end_date);
	switch(int_type) {
		case 0:
			log_debug("get yearly summary\n");
			break;
		case 1:
			log_debug("get monthly summary\n");
			ret_val	= get_daily_summary(start_date, end_date);
			break;
		case 2:
			log_debug("get daily summary\n");
			ret_val	= get_daily_summary(start_date, end_date);
			break;
		case 3:
			log_debug("get hourly summary\n");
			ret_val	= get_hourly_summary(start_date, end_date);
			break;
		case 4:
			log_debug("get minute summary data\n");
			break;
		case 5:
			log_debug("get second summary data\n");
			break;
	}
	return ret_val;
}