#include <stdio.h>
#include <string.h>
#include "logger.h"

template <typename T>
DataSet<T>::DataSet(T (*create_func)(), bool (*load_func)(T, const char*), bool (*done_func)(T), void (*destr_func)(T))
{
	create = create_func;
	load = load_func;
	done = done_func;
	destroy = destr_func;

	rman = resman_create();
	resman_set_load_func(rman, dataset_load_func, this);
	resman_set_done_func(rman, dataset_done_func, this);
	resman_set_destroy_func(rman, dataset_destroy_func, this);
}

template <typename T>
DataSet<T>::~DataSet()
{
	resman_free(rman);
}

template <typename T>
void DataSet<T>::clear()
{
	resman_free(rman);
	data.clear();

	rman = resman_create();
}

template <typename T>
void DataSet<T>::update(long timeslice)
{
	resman_setopt(rman, RESMAN_OPT_TIMESLICE, timeslice);
	resman_poll(rman);
}

template <typename T>
T DataSet<T>::get(const char *name) const
{
	typename std::map<std::string, T>::const_iterator iter = data.find(name);
	if(iter != data.end()) {
		return iter->second;
	}

	T res = create();
	data[name] = res;
	resman_add(rman, name, res);
	return res;
}

template <typename T>
int DataSet<T>::pending() const
{
	return resman_pending(rman);
}

template <typename T>
void DataSet<T>::wait() const
{
	resman_waitall(rman);
}

template <typename T>
void DataSet<T>::add_loaded_callback(LoadedCallbackFunc func, void *cls)
{
	std::pair<LoadedCallbackFunc, void*> cb;
	cb.first = func;
	cb.second = cls;
	loaded_cb.push_back(cb);
}

template <typename T>
bool DataSet<T>::remove_loaded_callback(LoadedCallbackFunc func)
{
	int numcb = (int)loaded_cb.size();
	for(int i=0; i<numcb; i++) {
		if(loaded_cb[i].first == func) {
			loaded_cb.erase(loaded_cb.begin() + i);
			return true;
		}
	}
	return false;
}


// --- static functions to pass as callback to resman ---

template <typename T>
int DataSet<T>::dataset_load_func(const char *fname, int id, void *cls)
{
	DataSet<T> *dset = (DataSet<T>*)cls;
	T data = (T)resman_get_res_data(dset->rman, id);
	if(!data) return -1;

	if(!dset->load(data, fname)) {
		return -1;
	}
	return 0;
}

template <typename T>
int DataSet<T>::dataset_done_func(int id, void *cls)
{
	DataSet<T> *dset = (DataSet<T>*)cls;

	T data = (T)resman_get_res_data(dset->rman, id);
	int load_res = resman_get_res_result(dset->rman, id);

	if(load_res != 0) {
		error_log("failed to load resource %d (%s)\n", id, resman_get_res_name(dset->rman, id));
	} else {
		info_log("done loading resource %d (%s)\n", id, resman_get_res_name(dset->rman, id));
	}

	if(dset->done) {
		dset->done(data);
	}

	int numcb = (int)dset->loaded_cb.size();
	for(int i=0; i<numcb; i++) {
		dset->loaded_cb[i].first(data, dset->loaded_cb[i].second);
	}
	return 0;
}

template <typename T>
void DataSet<T>::dataset_destroy_func(int id, void *cls)
{
	DataSet<T> *dset = (DataSet<T>*)cls;
	T data = (T)resman_get_res_data(dset->rman, id);

	if(dset->destroy) {
		dset->destroy(data);
	}
}