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

#include "W1Util.hh"
#include "W1DataList.hh"
#include "W1Store.hh"
#include "DeviceConfig.hh"

#include "plp/log.h"

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

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

	device_config		= new DeviceConfig(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);
}

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

Data *W1DataList::find_oldest_data(vector<string> year_vector) {
	unsigned int 	ii;
	string		year_dir;
	string		month_dir;
	vector<string>	month_vector;
	vector<string>	data_vector;
	string		f_name;
	W1Store		*store;
	Data		*ret_val;

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

Data *W1DataList::find_newest_data(vector<string> year_vector) {
	int 		ii;
	string		year_dir;
	string		month_dir;
	vector<string>	month_vector;
	vector<string>	data_vector;
	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_dir	= year_vector.at(size - 1);
		year_dir	= W1Util::concat_paths(device_dir, year_dir);
		month_vector	= W1Util::get_subdirectories(year_dir);
		for (ii = month_vector.size() - 1; ii >= 0; ii--) {
			month_dir	= month_vector.at(ii);
			month_dir	= W1Util::concat_paths(year_dir, month_dir);
			// scan data files from month dir
			data_vector	= W1Util::get_data_files(month_dir);
			size	= data_vector.size();
			if (size > 0) {
				f_name	= data_vector.at(size - 1);
				f_name	= W1Util::concat_paths(month_dir, f_name);
				store	= new W1Store(f_name);
				ret_val	= store->get_newest_data();
				delete(store);
				break;
			}
		}
	}
	return ret_val;
}

DataRange *W1DataList::get_data_range() {
	DataRange	*ret_val;
	vector<string>	year_list;
	Data		*first_data;
	Data		*newest_data;

	ret_val		= NULL;
	year_list	= W1Util::get_subdirectories(device_dir);
	first_data	= find_oldest_data(year_list);
	if (first_data != NULL) {
		newest_data	= find_newest_data(year_list);
		if (newest_data != NULL) {
			ret_val	= new DataRange(*first_data);
			ret_val->add_data(*newest_data);
			delete(newest_data);
		}
		delete(first_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 *W1DataList::get_daily_summary(Date *date) {
	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();
			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;
	}
	ret_val->printout();
	delete(store);

	return ret_val;
}

DataRange *W1DataList::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_daily_summary(date);
		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 *W1DataList::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");
			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");
			break;
		case 4:
			log_debug("get minute summary data\n");
			break;
		case 5:
			log_debug("get second summary data\n");
			break;
	}
	return ret_val;
}