/*
 * StoreCache.cc
 *
 *  Created on: Jan 6, 2011
 *      Author: lamikr
 */
#include <plp/log.h>

#include "Store.hh"
#include "StoreCache.hh"
#include "StoreDay.hh"
#include "DeviceConfig.hh"
#include "W1Util.hh"

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

StoreCache::StoreCache(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,
				period_type_param,
				calc_type_param);
*/
}

StoreCache::~StoreCache() {
}

string StoreCache::get_dir_name(string device_id_param,
				Date *date_time_param,
				EnumSummaryPeriod period_type_param,
				EnumSummaryCalculationType calc_type_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	= W1Util::concat_paths(bd_name, CACHE_DIR_NAME);
	bd_name	= W1Util::concat_paths(bd_name, device_id_param);
	bd_name	= W1Util::concat_paths(bd_name, SUMMARY_PERIOD_NAMES_ARRAY[period_type_param]);
	bd_name	= W1Util::concat_paths(bd_name, CALCULATION_TYPE_NAMES_ARRAY[calc_type_param]);
	ret_val	= bd_name + "/" + buffer;
	return ret_val;
}

string StoreCache::get_file_name(string device_id_param,
				Date *date_time_param,
				EnumSummaryPeriod period_type_param,
				EnumSummaryCalculationType calc_type_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_param, date_time_param, period_type_param, calc_type_param);
	ret_val	= W1Util::concat_paths(ret_val, fname);
	return ret_val;
}

DataRange *StoreCache::get_mean(EnumSummaryPeriod period_type_param) {
	int		row_count;
	DataRange	*ret_val;
	Data		*dta;
	string		fname;
	StoreDay 	*store;

	ret_val	= NULL;
	fname	= get_file_name(device_id,
				date,
				period_type_param,
				MEAN);
	if (store_data == NULL) {
		if (access(fname.c_str(), R_OK) == 0) {
			load(fname);
		}
	}
	if (store_data != NULL) {
		row_count	= store_data->get_count();
		if (row_count > 0) {
			ret_val	= new DataRange();
			dta	= store_data->get(0);
			ret_val->add(dta);
			delete(dta);
		}
	}
	if (ret_val == NULL) {
		store	= new StoreDay(device_id, date);
		ret_val	= store->get_mean(period_type_param);
		save(fname, ret_val, 4);
		delete(store);
	}
	return ret_val;
}

DataRange *StoreCache::get_sum(EnumSummaryPeriod period_type_param) {
	int		row_count;
	DataRange	*ret_val;
	Data		*dta;
	string		fname;
	StoreDay	*store;

	ret_val	= NULL;
	fname	= get_file_name(device_id,
				date,
				period_type_param,
				MEAN);
	if (store_data == NULL) {
		if (access(fname.c_str(), R_OK) == 0) {
			load(fname);
		}
	}
	if (store_data != NULL) {
		row_count	= store_data->get_count();
		if (row_count > 0) {
			ret_val	= new DataRange();
			dta	= store_data->get(0);
			ret_val->add(dta);
			delete(dta);
		}
	}
	if (ret_val == NULL) {
		store	= new StoreDay(device_id, date);
		ret_val	= store->get_sum(period_type_param);
		save(fname, ret_val, 4);
		delete(store);
	}
	return ret_val;
}

DataRange *StoreCache::get_delta(EnumSummaryPeriod period_type_param) {
	int		row_count;
	DataRange	*ret_val;
	Data		*dta;
	string		fname;
	StoreDay 	*store;

	ret_val	= NULL;
	fname	= get_file_name(device_id,
				date,
				period_type_param,
				MEAN);
	if (store_data == NULL) {
		if (access(fname.c_str(), R_OK) == 0) {
			// read from cache file
			load(fname);
		}
	}
	if (store_data != NULL) {
		row_count	= store_data->get_count();
		if (row_count > 0) {
			ret_val	= new DataRange();
			dta	= store_data->get(0);
			ret_val->add(dta);
			delete(dta);
		}
	}
	if (ret_val == NULL) {
		store	= new StoreDay(device_id, date);
		ret_val	= store->get_delta(period_type_param);
		save(fname, ret_val, 4);
		delete(store);
	}
	return ret_val;
}

DataRange *StoreCache::get_max(EnumSummaryPeriod period_type_param) {
	int		row_count;
	DataRange	*ret_val;
	Data		*dta;
	string		fname;
	StoreDay 	*store;

	ret_val	= NULL;
	fname	= get_file_name(device_id,
				date,
				period_type_param,
				MEAN);
	if (store_data == NULL) {
		if (access(fname.c_str(), R_OK) == 0) {
			load(fname);
		}
	}
	if (store_data != NULL) {
		row_count	= store_data->get_count();
		if (row_count > 0) {
			ret_val	= new DataRange();
			dta	= store_data->get(0);
			ret_val->add(dta);
			delete(dta);
		}
	}
	if (ret_val == NULL) {
		store	= new StoreDay(device_id, date);
		ret_val	= store->get_max(period_type_param);
		save(fname, ret_val, 4);
		delete(store);
	}
	return ret_val;
}

DataRange *StoreCache::get_min(EnumSummaryPeriod period_type_param) {
	int		row_count;
	DataRange	*ret_val;
	Data		*dta;
	string		fname;
	StoreDay 	*store;

	ret_val	= NULL;
	fname	= get_file_name(device_id,
				date,
				period_type_param,
				MEAN);
	if (store_data == NULL) {
		if (access(fname.c_str(), R_OK) == 0) {
			load(fname);
		}
	}
	if (store_data != NULL) {
		row_count	= store_data->get_count();
		if (row_count > 0) {
			ret_val	= new DataRange();
			dta	= store_data->get(0);
			ret_val->add(dta);
			delete(dta);
		}
	}
	if (ret_val == NULL) {
		store	= new StoreDay(device_id, date);
		ret_val	= store->get_min(period_type_param);
		save(fname, ret_val, 4);
		delete(store);
	}
	return ret_val;
}

void StoreCache::save(std::string fname_param, plp::DataRange *datarange_param, int decimal_count_param) {
	string		line;
	Data		*data;
	ofstream	*ostream;
	int		ii;
	int		cnt;

	cnt	= datarange_param->get_count();
	ostream	=  NULL;
	log_info("[%s] cacheing %d data values.\n", device_id.c_str(), cnt);
	ostream	= W1Util::open_for_writing(fname_param.c_str());
	if ((ostream != NULL) &&
	    (ostream->is_open() == true)) {
		// TODO: add mutex to protect string_list while it's read and emptied
		for(ii = 0; ii < cnt; ii++) {
			data	= datarange_param->get(ii);
			if (data != NULL) {
				line	= data->to_string(decimal_count_param);
				if (line.length() > 0) {
					*ostream << line << endl;
				}
				delete(data);
			}
		}
	}
	else {
		log_error("[%s] File open for data save failed: %s\n", device_id.c_str(), fname_param.c_str());
	}
	if (ostream != NULL) {
		ostream->close();
		delete(ostream);
	}
}