#ifndef CACHABLE_H
#define CACHABLE_H

#include<map>
#include<unordered_map>
#include<tuple>
#include<functional>
#include<type_traits>

namespace cachable {

template<typename T>
void hashcomb(std::size_t &x, T &&v) {
	x ^= std::hash<typename std::remove_cv<
			typename std::remove_reference<T>::type>::type>()(v)
		+ 0x9e3779b9 + (x<<6) + (x>>2);
}

template<std::size_t I, typename... T>
struct tuplehashfnreal {
	static void call(std::size_t &x, const std::tuple<T...> &p) {
		tuplehashfnreal<I-1,T...>::call(x,p);
		hashcomb(x,std::get<I-1>(p));
	}
};

template<typename ...T>
struct tuplehashfnreal<0,T...> {
	static void call(std::size_t &x, const std::tuple<T...> &p) {
	}
};

template<typename... T>
struct tuplehash : public std::unary_function<std::tuple<T...>,std::size_t> {
	std::size_t operator()(const std::tuple<T...> &p) const {
		std::size_t ret = 0;
		tuplehashfnreal<std::tuple_size<std::tuple<T...>>::value,
					T...>::call(ret,p);
		return ret;
	}
};

template<typename RetT, typename ...Params>
class memocache {
public:
	typedef std::tuple<Params...> InT;

	template <typename... T>
	const RetT *find(T &&...p) const { 
		static_assert(sizeof...(T) == sizeof...(Params),
			"cachable::memocache::find called with wrong parameters");
		auto loc = cache.find(std::forward_as_tuple(p...));
		if (loc==cache.end()) return nullptr;
		return &(loc->second);
	}

	template <typename RT, typename... T>
	RetT &add(RT &&out, T &&...in) {
		static_assert(sizeof...(T) == sizeof...(Params),
			"cachable::memocache::add called with wrong parameters");
		return cache[std::forward_as_tuple(in...)] = out;
	}

private:
	std::unordered_map<InT,RetT,tuplehash<Params...>> cache;
	//std::map<InT,RetT> cache;
};

namespace inner {
	template<typename F, typename RT,typename ...PT>
	inline std::function<RT(PT...)> _cachable(F &fn, RT (F::*)(PT...) const) {
		return [fn](PT ...params)->RT {
			static memocache<RT,PT...> _cache;
			auto loc = _cache.find(params...);
			if (loc==nullptr) return _cache.add(fn(params...),params...);
			else return *loc;
		};
	}
}

template<typename F>
inline auto cachable(F fn) -> decltype(inner::_cachable(fn,&F::operator())) {
	return inner::_cachable(fn,&F::operator());
}

} // end cachable namespace

#endif