#include <list>
#include <unordered_map>
#include <stdio.h>
#include <type_traits>
#include <functional>

template<int N, typename KeyType>
struct LookupKey {
	typedef KeyType type;
	static const int n = N;
};

template<typename Type>
const std::list<Type>& EmptyList() {
	static const std::list<Type> list;
	return list;
}

template<typename ValueType, typename... Keys>
class LookupTable {
	static_assert(sizeof...(Keys) > 0, "lookup table must have at least one key");

	public:
		typedef const std::list<ValueType>& result_type;

	private:	
		template<int = 0>
		void _build() { /* done! */ }
		
		template<typename Key, typename... RemKeys>
		void _build() {
			_columns[sizeof...(Keys) - sizeof...(RemKeys) - 1] = new std::unordered_map<typename Key::type, std::list<ValueType>>();
			return _build<RemKeys...>();
		}

		template<int = 0>
		void _destroy() { /* done! */ }
		
		template<typename Key, typename... RemKeys>
		void _destroy() {
			delete (std::unordered_map<typename Key::type, std::list<ValueType>>*)_columns[sizeof...(Keys) - sizeof...(RemKeys) - 1];
			return _destroy<RemKeys...>();
		}

		// search functions

		template<int SearchKey, typename SearchType, typename Key, typename T, typename... RemKeys>
		result_type _check_match(typename T::type& search) {
			auto map = (std::unordered_map<typename Key::type, std::list<ValueType>>*)_columns[sizeof...(Keys) - sizeof...(RemKeys) - 1];
			auto it = map->find(search);
			return it == map->end() ? EmptyList<ValueType>() : it->second;
		}

		template<int SearchKey, typename SearchType, typename Key, typename T, typename... RemKeys>
		result_type _check_match(SearchType& search) {
			return _lookup<SearchKey, SearchType, RemKeys...>(search);
		}

		template<int SearchKey, typename SearchType>
		result_type _lookup(SearchType& search) {
			static_assert(SearchKey != SearchKey, "key not found");
		}
		
		template<int SearchKey, typename SearchType, typename Key, typename... RemKeys>
		result_type _lookup(SearchType& search) {
			return _check_match<SearchKey, SearchType, Key, std::enable_if<SearchKey == Key::n, SearchType>, RemKeys...>(search);
		}
		
		// insert functions

		template <int = 0>
		void _insert(ValueType& value) { /* done! */ }
		
		template <typename Key, typename... RemKeys, typename KeyValue, typename... RemKeyValues>
		void _insert(ValueType& value, KeyValue& keyValue, RemKeyValues&... rem) {
			auto map = (std::unordered_map<typename Key::type, std::list<ValueType>>*)_columns[sizeof...(Keys) - sizeof...(RemKeys) - 1];
			(*map)[keyValue].push_back(value);
			return _insert<RemKeys...>(value, rem...);
		}

	public:	
		LookupTable() {
			_build<Keys...>();
		}
		
		~LookupTable() {
			_destroy<Keys...>();
		}

		template<int SearchKey, typename SearchType>
		result_type lookup(SearchType search) {
			return _lookup<SearchKey, SearchType, Keys...>(search);
		}

		template<typename... KeyValues>
		void insert(ValueType value, KeyValues... keyValues) {
			static_assert(sizeof...(KeyValues) == sizeof...(Keys), "wrong number of keys");
			return _insert<Keys...>(value, keyValues...);
		}

	private:
		void* _columns[sizeof...(Keys)];
};