#ifndef DIM_HPP
#define DIM_HPP

#include <boost/preprocessor/arithmetic/dec.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/punctuation/comma_if.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/for.hpp>
#include <boost/preprocessor/seq.hpp>
#include <boost/preprocessor/tuple/eat.hpp>

#include <cassert>

namespace dim {

	#define DIM_BASE_UNITS \
		(mass)(time)(length)(current)(temperature)(amount_of_substance)(intensity) \
		/**/

	#define SEQ DIM_BASE_UNITS

	#define M1(r, _, i, x) \
		BOOST_PP_COMMA_IF(i) int x \
		/**/

	template<BOOST_PP_SEQ_FOR_EACH_I(M1, ~, SEQ)> struct dimensions {
		inline dimensions(void) {
			return;
		}
		#define M2(r, _, x) \
			char (& BOOST_PP_CAT(x, _magnitude)(void) const)[1 + (x < 0 ? -x : x)]; \
			char (& BOOST_PP_CAT(x, _sign)(void) const)[1 + (x < 0)]; \
			/**/
		BOOST_PP_SEQ_FOR_EACH(M2, ~, SEQ)
		#undef M2
	};

	#undef M1

	const dimensions<BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_FOR_EACH((0) BOOST_PP_TUPLE_EAT(3), ~, SEQ))> scalar;

	#define PRED(s, nss) BOOST_PP_SEQ_ELEM(0, nss)
	#define OP(s, nss) \
		( BOOST_PP_DEC(BOOST_PP_SEQ_ELEM(0, nss))         ) \
		( BOOST_PP_SEQ_TAIL(BOOST_PP_SEQ_ELEM(1, nss))(0) ) \
		( BOOST_PP_SEQ_TAIL(BOOST_PP_SEQ_ELEM(2, nss))(0) ) \
		/**/
	#define MACRO(s, nss) \
		const dimensions<BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_ELEM(2, nss))> \
			BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_ELEM(1, nss)); \
		/**/

	BOOST_PP_FOR(
		( BOOST_PP_SEQ_SIZE(SEQ)                                                        )
		( BOOST_PP_SEQ_REVERSE(SEQ)                                                     )
		( BOOST_PP_SEQ_FOR_EACH((0) BOOST_PP_TUPLE_EAT(3), ~, BOOST_PP_SEQ_TAIL(SEQ))(1) ),
		PRED, OP, MACRO
	)

	#undef PRED
	#undef OP
	#undef MACRO

	#define DEF(op1, op2, size) \
		template<BOOST_PP_ENUM_PARAMS(size, int X), BOOST_PP_ENUM_PARAMS(size, int Y)> \
			dimensions<BOOST_PP_ENUM_BINARY_PARAMS(size, X, op1 Y)> \
			operator op2(dimensions<BOOST_PP_ENUM_PARAMS(size, X)>, dimensions<BOOST_PP_ENUM_PARAMS(size, Y)>); \
		/**/

	DEF(+, *, BOOST_PP_SEQ_SIZE(SEQ))
	DEF(-, /, BOOST_PP_SEQ_SIZE(SEQ))

	#undef DEF	

	#undef SEQ

	// ------------------------------ //

	#define DIM(x) \
		dim::dimensions< \
			BOOST_PP_SEQ_FOR_EACH_I( \
				DIM_PRIVATE, x, DIM_BASE_UNITS \
			) \
		> \
		/**/
	#define DIM_PRIVATE(r, y, i, x) \
		BOOST_PP_COMMA_IF(i) ((int)sizeof((y).BOOST_PP_CAT(x, _magnitude)()) - 1) * (sizeof((y).BOOST_PP_CAT(x, _sign)()) == 1 ? 1 : -1) \
		/**/

	// ------------------------------ //

	template<class T, class D> class quantity {
		public:
			typedef D dimensions;
			inline quantity(T x) : x_(x) {
				return;
			}
			inline T value(void) const {
				return x_;
			}
		private:
			T x_;
	};

	template<class T, class D> inline quantity<T, D> operator+(quantity<T, D> x) {
		return x;
	}

	template<class T, class D> inline quantity<T, D> operator-(quantity<T, D> x) {
		return -x.value();
	}

	template<class T, class D> inline quantity<T, D> operator+(quantity<T, D> x, quantity<T, D> y) {
		return x.value() + y.value();
	}

	template<class T, class D> inline quantity<T, D> operator-(quantity<T, D> x, quantity<T, D> y) {
		return x.value() - y.value();
	}

	namespace hack {

		template<class D1, class D2> struct multiply {
			typedef DIM(D1() * D2()) type;
		};

		template<class D1, class D2> struct divide {
			typedef DIM(D1() / D2()) type;
		};

	}

	template<class T, class D1, class D2> inline quantity<T, typename hack::multiply<D1, D2>::type> operator*(quantity<T, D1> x, quantity<T, D2> y) {
		return x.value() * y.value();
	}

	template<class T, class D1, class D2> inline quantity<T, typename hack::divide<D1, D2>::type> operator/(quantity<T, D1> x, quantity<T, D2> y) {
		assert(y.value());
		return x.value() / y.value();
	}

}

#endif