#pragma once
namespace DD {
	/** Shortcut for simple referencing native arrays. */
	template<typename TYPE, size_t N>
	using ArrayNative = TYPE[N];

	/************************************************************************/
	/* TypeSizeCheck.                                                       */
	/************************************************************************/

	/** Safety check scheme. */
	template<typename T, size_t BYTES>
	struct TypeSizeCheckT {
		/** Safety check. */
		static_assert(sizeof(T) == BYTES, "Type size is invalid.");
		/** Type forwarder type. */
		using Type = T;
	};

	/** Safety check. */
	template<typename T, size_t BYTES>
	using TypeSizeCheck = typename TypeSizeCheckT<T, BYTES>::Type;


	/************************************************************************/
	/* Types.                                                               */
	/************************************************************************/

	/** Table of basic types according to byte size. */
	template<size_t BYTE_SIZE>
	struct Types;

	/** 1-byte types. */
	template<>
	struct Types<1> {
		using Unsigned = TypeSizeCheck<unsigned char, 1>;
		using Signed   = TypeSizeCheck<signed char, 1>;
	};

	/** 2-byte types. */
	template<>
	struct Types<2> {
		using Unsigned = TypeSizeCheck<unsigned short, 2>;
		using Signed   = TypeSizeCheck<signed short, 2>;
	};

	/** 4-byte types. */
	template<>
	struct Types<4> {
#if DD_COMPILE_ARDUINO
		using Unsigned = TypeSizeCheck<unsigned long, 4>;
		using Signed   = TypeSizeCheck<  signed long, 4>;
#else
		using Unsigned = TypeSizeCheck<unsigned, 4>;
		using Signed   = TypeSizeCheck<     int, 4>;
#endif
		using Float    = TypeSizeCheck<   float, 4>;
	};

	/** 8-byte types. */
	template<>
	struct Types<8> {
		using Unsigned = TypeSizeCheck<unsigned long long, 8>;
		using Signed   = TypeSizeCheck<  signed long long, 8>;
		using Float    = TypeSizeCheck<            double, 8>;
	};


	/************************************************************************/
	/* Typedefs.                                                            */
	/************************************************************************/

	/** Signed types. */
	template<size_t BYTES>
	using Signed = typename Types<BYTES>::Signed;
	template<typename T>
	using SignedT = Signed<sizeof(T)>;

	/** Unsigned types. */
	template<size_t BYTES>
	using Unsigned = typename Types<BYTES>::Unsigned;
	template<typename T>
	using UnsignedT = Unsigned<sizeof(T)>;

	/** Float types. */
	template<size_t BYTES>
	using Float = typename Types<BYTES>::Float;
	template<typename T>
	using FloatT = Float<sizeof(T)>;

	/** 8-bit types. */
	using Types8  = Types<1>;
	using u8 = Unsigned<1>;
	using i8 = Signed<1>;

	/** 16-bit types. */
	using Types16 = Types<2>;
	using u16 = Unsigned<2>;
	using i16 = Signed<2>;

	/** 32-bit types. */
	using Types32 = Types<4>;
	using u32 = Unsigned<4>;
	using i32 = Signed<4>;
	using f32 = Float<4>;

	/** 64-bit types. */
	using Types64 = Types<8>;
	using u64 = Unsigned<8>;
	using i64 = Signed<8>;
	using f64 = Float<8>;

	/** Other. */
	using Null = decltype(nullptr);

	/************************************************************************/
	/* Casting helpers.                                                     */
	/************************************************************************/
	template<typename T>
	constexpr SignedT<T> & AsSigned(T & t) { return reinterpret_cast<SignedT<T> &>(t); }
	template<typename T>
	constexpr const SignedT<T> & AsSigned(const T & t) { return reinterpret_cast<const SignedT<T> &>(t); }
	template<typename T>
	constexpr UnsignedT<T> & AsUnsigned(T & t) { return reinterpret_cast<UnsignedT<T> &>(t); }
	template<typename T>
	constexpr const UnsignedT<T> & AsUnsigned(const T & t) { return reinterpret_cast<const UnsignedT<T> &>(t); }
}