/*
 * test.cpp
 *
 *  Created on: 08.10.2016
 *      Author: mike
 */

#include <cstdint>
#include <string>
#include <vector>
#include <unordered_map>
#include <boost/blank.hpp>
#include <boost/date_time/posix_time/ptime.hpp>
#include <boost/variant.hpp>

namespace hessian {

struct hash;

using null_t = boost::blank;
using bool_t = bool;
using int_t = std::int32_t;
using long_t = std::int64_t;
using double_t = double;
using date_t = boost::posix_time::ptime;
using string_t = std::string;
using binary_t = std::basic_string<std::uint8_t>;

template <typename T>
using basic_list_t = std::vector<T>;

template <typename T>
using basic_map_t = std::unordered_map<T, T, hash>;

template <typename T>
using basic_object_t = std::unordered_map<string_t, T>;

using value_t = boost::make_recursive_variant
<
	null_t,
	bool_t,
	int_t,
	long_t,
	double_t,
	date_t,
	string_t,
	binary_t,
	basic_list_t<boost::recursive_variant_>,
	basic_map_t<boost::recursive_variant_>,
	basic_object_t<boost::recursive_variant_>
>::type;

using list_t = basic_list_t<value_t>;
using map_t = basic_map_t<value_t>;
using object_t = basic_object_t<value_t>;

struct hash
{
	size_t operator()(const value_t& value) const noexcept;
};

}

#include <boost/variant/detail/hash_variant.hpp>

namespace boost {

size_t
hash_value(const hessian::null_t& value) noexcept;

size_t
hash_value(const hessian::date_t& value) noexcept;

size_t
hash_value(const hessian::map_t& value) noexcept;

size_t
hash_value(const hessian::object_t& value) noexcept;

}

#include <boost/functional/hash.hpp>

namespace boost {

inline size_t
hash_value(const hessian::null_t& value) noexcept
{
	return 0xAAAAAAAAAAAAAAAA;
}

inline size_t
hash_value(const hessian::date_t& value) noexcept
{
	size_t seed = 0;
	hash_combine(seed, value.date().day_count().as_number());
	hash_combine(seed, value.time_of_day().total_milliseconds());
    return seed;
}

inline size_t
hash_value(const hessian::map_t& value) noexcept
{
	return hash_range(value.begin(), value.end());
}

inline size_t
hash_value(const hessian::object_t& value) noexcept
{
	return hash_range(value.begin(), value.end());
}

}

namespace hessian {

inline size_t
hash::operator()(const value_t& value) const noexcept
{
	return boost::hash_value(value);
}

}

int main()
{
	using namespace hessian;
	using namespace std::string_literals;

	value_t value;

	value = null_t();
	value = map_t
	{
		{int_t(1), bool_t(true)},
		{long_t(2), double_t(3.14)}
	};
	value = object_t
	{
		{"foo"s, bool_t(true)},
		{"bar"s, double_t(3.14)}
	};

	return 0;
}