/*
 * Store.cc
 *
 *  Created on: Oct 31, 2010
 *      Author: lamikr
 */

#include <list>
#include <string>
#include <fstream>
#include <limits>

#include <time.h>
#include <dirent.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

#include "log.h"
#include "DeviceConfig.hh"
#include "StoreDay.hh"
#include "FileUtil.hh"

using namespace std;
using namespace plp;

StoreDay::StoreDay(string device_id_param,
		Date *date_time_param): Store(device_id_param, date_time_param) {
	store_fname	= get_file_name(device_id_param, date_time_param);
}

StoreDay::StoreDay(string fname_param): Store("", NULL) {
	store_data	= NULL;
	range_data	= NULL;
	store_fname	= fname_param;
}

StoreDay::~StoreDay() {
	if (store_data != NULL) {
		delete(store_data);
		store_data	= NULL;
	}
}

string StoreDay::get_year_dir_name(string device_id,
				Date *date_time_param) {
	string	ret_val;
	char	buffer[10];
	string  bd_name;

	snprintf(buffer, 10, "%d", date_time_param->year);
	bd_name	= DeviceConfig::get_base_dir_name();
	bd_name	= FileUtil::concat_paths(bd_name, device_id);
	ret_val	= bd_name + "/" + buffer;
	return ret_val;
}

string StoreDay::get_dir_name(string device_id,
			Date *date_time_param) {
	string	ret_val;
	char	buffer[30];
	string  bd_name;

	snprintf(buffer, 30, "%d/%02d", date_time_param->year, date_time_param->month);
	bd_name	= DeviceConfig::get_base_dir_name();
	bd_name	= FileUtil::concat_paths(bd_name, device_id);
	ret_val	= bd_name + "/" + buffer;
	return ret_val;
}

string StoreDay::get_file_name(string device_id,
			Date *date_time_param) {
	string	ret_val;
	string	fname;
	char	buffer[30];

	snprintf(buffer,
		30,
		"%d-%02d-%02d",
		date_time_param->year,
		date_time_param->month,
		date_time_param->day);
	fname	= buffer;
	fname	= fname + DATAFILE_SUFFIX;
	ret_val	= get_dir_name(device_id, date_time_param);
	ret_val	= FileUtil::concat_paths(ret_val, fname);
	return ret_val;
}

void StoreDay::save(string device_id,
		std::list<Data *> *data_list,
		int dec_precision) {
	string			n_path;
	string			f_path;
	string			line;
	Data			*data;
	ofstream		*ostream;
	Date			date;
	list<Data *>::iterator	iter;

	ostream	=  NULL;
	f_path	= "";
	/* needs to be casted to long unsigned int value is "unsigned int" in some
           toolchains and that would otherwise cause an warning/error 
        */
	log_info("[%s] saving %lu data values.\n", device_id.c_str(),
		(long unsigned int)data_list->size());
	// TODO: add mutex to protect string_list while it's read and emptied
	for(iter = data_list->begin(); iter != data_list->end(); iter++) {
		data	= (Data *)*iter;
		date	= data->get_date();
		n_path	= get_file_name(device_id, &date);
		if (n_path.compare(f_path) != 0) {
			if (ostream != NULL) {
				ostream->close();
				delete(ostream);
			}
			f_path	= n_path;
			log_info("[%s] Opening file for save: %s\n", device_id.c_str(), f_path.c_str());
			ostream	= FileUtil::open_for_writing(f_path.c_str());
		}
		if ((ostream != NULL) &&
		    (ostream->is_open() == true)) {
			line	= data->to_string(dec_precision);
			if (line.length() > 0) {
				log_debug("storing line: %s\n", line.c_str());
				*ostream << line << endl;
			}
		}
		else {
			log_error("[%s] File open for data save failed: %s\n", device_id.c_str(), f_path.c_str());
		}
	}
	if (ostream != NULL) {
		ostream->close();
		delete(ostream);
	}
}

bool StoreDay::load() {
	return Store::load(store_fname);
}

bool StoreDay::exist(string fname_param, bool writable) {
	bool	ret_val;
	ret_val	= FileUtil::file_exist(fname_param.c_str(), writable);
	return ret_val;
}

bool StoreDay::exist(string dev_id_param,
		Date *date,
		bool writable) {
	bool	ret_val;
	string	f_name;

	f_name	= get_file_name(dev_id_param, date);
	ret_val	= FileUtil::file_exist(f_name.c_str(), writable);
	return ret_val;
}

bool StoreDay::exist_in_month(string dev_id_param,
			Date *date,
			bool writable) {
	string	dirname;
	bool	ret_val;

	dirname = StoreDay::get_dir_name(dev_id_param, date);
	ret_val	= FileUtil::dir_exist(dirname.c_str(), writable);
	return ret_val;
}

bool StoreDay::exist_in_year(string dev_id_param,
			Date *date,
			bool writable) {
	string	dirname;
	bool	ret_val;

	dirname = StoreDay::get_year_dir_name(dev_id_param, date);
	ret_val	= FileUtil::dir_exist(dirname.c_str(), writable);
	return ret_val;
}

bool StoreDay::exist(bool writable) {
	return exist(store_fname, writable);
}

static int get_summary_period_as_freq_seconds(EnumSummaryPeriod period_type_param) {
	int	ret_val;

	ret_val	= 3600;
	switch(period_type_param) {
		case PERIOD_SECONDLY:
			ret_val	= 1;
			break;
		case PERIOD_MINUTELY:
			ret_val	= 60;
			break;
		case PERIOD_HOURLY:
			ret_val	= 3600;
			break;
		case PERIOD_DAILY:
		case PERIOD_MONTHLY:
		case PERIOD_YEARLY:
		default:
			// -1 as freq means that show all data from the current store
			ret_val	= -1;
			break;
	}
	return ret_val;
}

plp::DataRange *StoreDay::get_sum(EnumSummaryPeriod period_type_param) {
	int		row_count;
	int		col_count;
	int		jj;
	int		ii;
	Data 		*data;
	Data 		*calc;
	Date		*limit_d;
	Date		date;
	DataRange	*ret_val;
	int		frq_sec;
	bool		succ;

	ret_val	= NULL;
	calc	= NULL;
	limit_d	= NULL;
	succ	= true;
	frq_sec	= get_summary_period_as_freq_seconds(period_type_param);
	if (store_data == NULL) {
		succ	= load();
	}
	if ((succ == true) &&
	    (store_data != NULL)) {
		row_count	= store_data->get_count();
		if (row_count > 0) {
			col_count	= store_data->get_data_item_value_count();
			if (col_count > 0) {
				ret_val	= new DataRange();
				for (ii = 0; ii < row_count; ii++) {
					data	= store_data->get(ii);
					if (data != NULL) {
						if (calc == NULL) {
							calc		= data->clone();
							limit_d		= data->get_date().clone();
							limit_d->min	= 0;
							limit_d->sec	= 0;
							limit_d->inc_seconds(frq_sec);
						}
						date	= data->get_date();
						if ((ii <= (row_count -1)) &&
						    ((frq_sec == -1) || (date.before(limit_d)))) {
							for (jj = 0; jj < col_count; jj++) {
								calc->value_arr[jj]	= calc->value_arr[jj] + data->value_arr[jj];
							}
						}
						if ((ii >= (row_count -1)) ||
						    ((frq_sec != -1) && (date.before(limit_d) == false))) {
							ret_val->add(calc);
							delete(calc);
							calc	= data->clone();
							if (limit_d != NULL) {
								delete(limit_d);
							}
							limit_d		= data->get_date().clone();
							limit_d->min	= 0;
							limit_d->sec	= 0;
							limit_d->inc_seconds(frq_sec);
						}
						delete(data);
					}
				}
				if (calc != NULL) {
					delete(calc);
					calc	= NULL;
				}
				if (limit_d != NULL) {
					delete(limit_d);
				}
			}
		}
	}
	return ret_val;
}

plp::DataRange *StoreDay::get_mean(EnumSummaryPeriod period_type_param) {
	int		row_count;
	int		col_count;
	int		d_count;
	int		jj;
	int		ii;
	Data 		*data;
	Data 		*calc;
	Date		*limit_d;
	Date		date;
	DataRange	*ret_val;
	int		frq_sec;
	bool		succ;

	ret_val	= NULL;
	calc	= NULL;
	limit_d	= NULL;
	d_count	= 1;
	succ	= true;
	frq_sec	= get_summary_period_as_freq_seconds(period_type_param);
	if (store_data == NULL) {
		succ	= load();
	}
	if ((succ == true) &&
	    (store_data != NULL)) {
		row_count	= store_data->get_count();
		if (row_count > 0) {
			col_count	= store_data->get_data_item_value_count();
			if (col_count > 0) {
				ret_val	= new DataRange();
				for (ii = 0; ii < row_count; ii++) {
					data	= store_data->get(ii);
					if (data != NULL) {
						if (calc == NULL) {
							d_count		= 1;
							calc		= data->clone();
							limit_d		= data->get_date().clone();
							limit_d->min	= 0;
							limit_d->sec	= 0;
							limit_d->inc_seconds(frq_sec);
						}
						date	= data->get_date();
						if ((ii <= (row_count -1)) &&
						    ((frq_sec == -1) || (date.before(limit_d)))) {
							for (jj = 0; jj < col_count; jj++) {
								calc->value_arr[jj]	= calc->value_arr[jj] + data->value_arr[jj];
							}
							d_count++;
						}
						if ((ii >= (row_count -1)) ||
						    ((frq_sec != -1) && (date.before(limit_d) == false))) {
							for (jj = 0; jj < col_count; jj++) {
								calc->value_arr[jj]	= calc->value_arr[jj] / d_count;
							}
							ret_val->add(calc);
							delete(calc);
							d_count		= 1;
							calc		= data->clone();
							if (limit_d != NULL) {
								delete(limit_d);
							}
							limit_d		= data->get_date().clone();
							limit_d->min	= 0;
							limit_d->sec	= 0;
							limit_d->inc_seconds(frq_sec);
						}
						delete(data);
					}
				}
				if (calc != NULL) {
					delete(calc);
					calc	= NULL;
				}
				if (limit_d != NULL) {
					delete(limit_d);
				}
			}
		}
	}
	return ret_val;
}

plp::DataRange *StoreDay::get_delta(EnumSummaryPeriod period_type_param) {
	int		row_count;
	int		col_count;
	int		jj;
	int		ii;
	Data 		*data;
	Data 		*calc1;
	Data 		*calc2;
	Date		*limit_d;
	Date		date;
	DataRange	*ret_val;
	int		frq_sec;
	bool		succ;

	ret_val	= NULL;
	calc1	= NULL;
	calc2	= NULL;
	limit_d	= NULL;
	succ	= true;
	frq_sec	= get_summary_period_as_freq_seconds(period_type_param);
	if (store_data == NULL) {
		succ	= load();
	}
	if ((succ == true) &&
	    (store_data != NULL)) {
		row_count	= store_data->get_count();
		if (row_count > 0) {
			col_count	= store_data->get_data_item_value_count();
			if (col_count > 0) {
				ret_val	= new DataRange();
				for (ii = 0; ii < row_count; ii++) {
					data	= store_data->get(ii);
					if (data != NULL) {
						if (calc1 == NULL) {
							calc1		= data->clone();
							limit_d		= data->get_date().clone();
							limit_d->min	= 0;
							limit_d->sec	= 0;
							limit_d->inc_seconds(frq_sec);
							if (calc2 != NULL) {
								delete(calc2);
							}
							calc2		= NULL;
						}
						date	= data->get_date();
						if ((ii <= (row_count -1)) &&
						    ((frq_sec == -1) || (date.before(limit_d)))) {
							if (calc2 != NULL) {
								delete(calc2);
							}
							calc2	= data->clone();
						}
						if ((ii >= (row_count -1)) ||
						    ((frq_sec != -1) && (date.before(limit_d) == false))) {
							if (calc2 == NULL) {
								calc2	= calc1->clone();
							}
							for (jj = 0; jj < col_count; jj++) {
								calc2->value_arr[jj]	= calc2->value_arr[jj] - calc1->value_arr[jj];
							}
							ret_val->add(calc2);
							delete(calc1);
							calc1	= data->clone();
							delete(calc2);
							calc2	= NULL;
							if (limit_d != NULL) {
								delete(limit_d);
							}
							limit_d		= data->get_date().clone();
							limit_d->min	= 0;
							limit_d->sec	= 0;
							limit_d->inc_seconds(frq_sec);
						}
						delete(data);
					}
				}
				if (calc1 != NULL) {
					delete(calc1);
					calc1	= NULL;
				}
				if (calc2 != NULL) {
					delete(calc2);
					calc2	= NULL;
				}
				if (limit_d != NULL) {
					delete(limit_d);
				}
			}
		}
	}
	return ret_val;
}

plp::DataRange *StoreDay::get_max_or_min(EnumSummaryPeriod period_type_param, bool max) {
	int		row_count;
	int		col_count;
	int		jj;
	int		ii;
	Data 		*data;
	Data 		*calc;
	Date		*limit_d;
	Date		date;
	DataRange	*ret_val;
	int		frq_sec;
	bool		succ;

	ret_val	= NULL;
	calc	= NULL;
	limit_d	= NULL;
	frq_sec	= get_summary_period_as_freq_seconds(period_type_param);
	succ	= true;
	if (store_data == NULL) {
		succ	= load();
	}
	if ((succ == true) &&
	    (store_data != NULL)) {
		row_count	= store_data->get_count();
		if (row_count > 0) {
			col_count	= store_data->get_data_item_value_count();
			if (col_count > 0) {
				ret_val	= new DataRange();
				for (ii = 0; ii < row_count; ii++) {
					data	= store_data->get(ii);
					if (data != NULL) {
						if (calc == NULL) {
							calc		= data->clone();
							limit_d		= data->get_date().clone();
							limit_d->min	= 0;
							limit_d->sec	= 0;
							limit_d->inc_seconds(frq_sec);
						}
						date	= data->get_date();
						if ((ii <= (row_count -1)) &&
						    ((frq_sec == -1) || (date.before(limit_d)))) {
							int changed = 0;
							if (max == true) {
								for (jj = 0; jj < col_count; jj++) {
									if (calc->value_arr[jj] < data->value_arr[jj]) {
										calc->value_arr[jj]	= data->value_arr[jj];
										changed = 1;
									}
								}
							}
							else {
								for (jj = 0; jj < col_count; jj++) {
									if (data->value_arr[jj] < calc->value_arr[jj]) {
										calc->value_arr[jj]	= data->value_arr[jj];
										changed = 1;
									}
								}
							}
							if (changed == 1) {
								Date new_date;

								new_date	= data->get_date();
								calc->set_date(&new_date);
							}
						}
						if ((ii >= (row_count -1)) ||
						    ((frq_sec != -1) && (date.before(limit_d) == false))) {
							ret_val->add(calc);
							delete(calc);
							calc	= data->clone();
							if (limit_d != NULL) {
								delete(limit_d);
							}
							limit_d		= data->get_date().clone();
							limit_d->min	= 0;
							limit_d->sec	= 0;
							limit_d->inc_seconds(frq_sec);
						}
						delete(data);
					}
				}
				if (calc != NULL) {
					delete(calc);
					calc	= NULL;
				}
				if (limit_d != NULL) {
					delete(limit_d);
				}
			}
		}
	}
	return ret_val;
}

plp::DataRange *StoreDay::get_max(EnumSummaryPeriod period_type_param) {
	DataRange	*ret_val;

	ret_val = get_max_or_min(period_type_param, true);
	return ret_val;
}

plp::DataRange *StoreDay::get_min(EnumSummaryPeriod period_type_param) {
	DataRange	*ret_val;

	ret_val = get_max_or_min(period_type_param, false);
	return ret_val;
}

DataRange *StoreDay::get_oldest_and_latest_data(string fname_param) {
	DataRange	*ret_val;
	ifstream	in;
	Data		*o_data;
	Data		*n_data;
	string		latest;
	int		row_count;
	string		line;
	string		prev_line;

	ret_val	= NULL;
	o_data	= NULL;
	n_data	= NULL;
	if (store_data != NULL) {
		row_count	= store_data->get_count();
		if (row_count > 0) {
			o_data	= store_data->get(0);
			n_data	= store_data->get(row_count - 1);
		}
	}
	else {
		if (range_data != NULL) {
			row_count	= range_data->get_count();
			if (row_count > 0) {
				o_data	= range_data->get(0);
				n_data	= range_data->get(row_count - 1);
			}
		}
		else {
			in.open(fname_param.c_str());
			if (in.is_open() == true) {
				while (in.eof() == false) {
					getline(in, line);
					if (line.empty() == false) {
						if (o_data == NULL) {
							o_data	= Data::parse_string(line);
						}
						prev_line	= line;
					}
				}
				if (prev_line.empty() == false) {
					n_data	= Data::parse_string(prev_line);
				}
			}
		}
	}
	if ((o_data != NULL) &&
	    (n_data != NULL)) {
		ret_val	= new DataRange(o_data);
		ret_val->add(n_data);
		if (range_data != NULL) {
			range_data	= new DataRange(o_data);
			range_data->add(n_data);
		}
	}
	if (o_data != NULL) {
		delete(o_data);
	}
	if (n_data != NULL) {
		delete(n_data);
	}
	return ret_val;
}

DataRange *StoreDay::get_oldest_and_latest_data() {
	return get_oldest_and_latest_data(store_fname);
}

Data *StoreDay::get_oldest_data() {
	int		row_count;
	Data		*ret_val;
	DataRange	*dr;

	ret_val	= NULL;
	dr	= get_oldest_and_latest_data();
	if (dr != NULL) {
		row_count	= dr->get_count();
		if (row_count >= 1) {
			ret_val	= dr->get(0);
		}
		delete(dr);
	}
	return ret_val;
}

Data *StoreDay::get_latest_data() {
	int		row_count;
	Data		*ret_val;
	DataRange	*dr;

	ret_val	= NULL;
	dr	= get_oldest_and_latest_data();
	if (dr != NULL) {
		row_count	= dr->get_count();
		if (row_count == 2) {
			ret_val	= dr->get(1);
		}
		delete(dr);
	}
	return ret_val;
}

bool StoreDay::data_day_scan_days_in_month(string dev_id_param,
				Date *new_date,
				Date *max_date) {
	bool	ret_val;
	string	fname;

	ret_val	= false;
	while((ret_val == false) &&
	      (new_date->before(max_date))) {
		new_date->next_day();
		fname	= get_file_name(dev_id_param, new_date);
		if (exist(fname, false) == true) {
			ret_val	= true;
			break;
		}
		if (new_date->is_last_day_of_month() == true) {
			break;
		}
	}
	return ret_val;
}

bool StoreDay::data_day_scan_month_in_year(string dev_id_param,
				Date *new_date,
				Date *max_date) {
	bool	ret_val;

	ret_val	= false;
	// next scan months dir existence under the first year
	while((ret_val == false) &&
	      (new_date->before(max_date))) {
		new_date->next_month();
		if (exist_in_month(dev_id_param,
				new_date,
				false)) {
			ret_val	= data_day_scan_days_in_month(dev_id_param,
							new_date,
							max_date);
			if (ret_val == true)
				break;
		}
		if (new_date->month == 12)
			break;
	}
	return ret_val;
}

bool StoreDay::data_day_scan_years(string dev_id_param,
			Date *new_date,
			Date *max_date) {
	bool	ret_val;

	ret_val	= false;
	while((ret_val == false) &&
	      (new_date->before(max_date))) {
		new_date->next_year();
		if (exist_in_year(dev_id_param,
				new_date,
				false)) {
			ret_val	= data_day_scan_month_in_year(dev_id_param,
							new_date,
							max_date);
			if (ret_val == true)
				break;
		}
	}
	return ret_val;
}

bool StoreDay::get_next_date_with_data(std::string dev_id_param,
				plp::Date *next_date,
				plp::Date *max_date) {
	bool	ret_val;
	Date	*new_date;
	string	fname;
	string	dirname;

	new_date	= next_date->clone();
	// scan first dates in current month
	ret_val		= data_day_scan_days_in_month(dev_id_param,
						new_date,
						max_date);
	if (ret_val == false) {
		ret_val = data_day_scan_month_in_year(dev_id_param,
						new_date,
						max_date);
		if (ret_val == false) {
			ret_val = data_day_scan_years(dev_id_param,
						new_date,
						max_date);
		}
	}
	if (ret_val == true)
		new_date->copy(next_date);
	else
		max_date->copy(next_date);
	delete(new_date);
	return ret_val;
}