#include <functional>
#include <type_traits>

namespace sprawl
{
	namespace memory
	{
		template<size_t size, size_t align = 8>
		class OpaqueType;

		template<typename T>
		struct CreateAs{};
	}
}

#if (defined(_WIN32) && _MSC_VER < 1900)
#	define alignof __alignof
#endif

template<size_t size, size_t align>
class sprawl::memory::OpaqueType
{
public:
	class Deleter
	{
	public:
		virtual void Delete(void*) = 0;
	};

	template<typename T>
	class TypeDeleter : public Deleter
	{
	public:
		virtual void Delete(void* ptr)
		{
			reinterpret_cast<T*>(ptr)->~T();
		}
	};

	template<typename T, typename... Params>
	OpaqueType(CreateAs<T> const&, Params&&... params)
		: m_ptr()
		, m_deleter()
	{
		static_assert(sizeof(T) == size, "Opaque type delcared with size that does not match the type used to construct it.");
		static_assert(align >= alignof(T) && (align % alignof(T) == 0), "Opaque type definition does not match alignment requirements of the type used to construct it.");
		new(&m_ptr) T(std::forward<Params>(params)...);
		new(&m_deleter) TypeDeleter<T>();
	}

	~OpaqueType()
	{
		reinterpret_cast<Deleter*>(&m_deleter)->Delete(&m_ptr);
	}

	template<typename T>
	T& As()
	{
		static_assert(sizeof(T) == size, "Opaque type delcared with size that does not match the type used to access it.");
		static_assert(align >= alignof(T) && (align % alignof(T) == 0), "Opaque type definition does not match alignment requirements of the type used to access it.");
		return *reinterpret_cast<T*>(&m_ptr);
	}

	template<typename T>
	T const& As() const
	{
		static_assert(sizeof(T) == size, "Opaque type delcared with size that does not match the type used to access it.");
		static_assert(align >= alignof(T) && (align % alignof(T) == 0), "Opaque type definition does not match alignment requirements of the type used to access it.");
		return *reinterpret_cast<T*>(&m_ptr);
	}

	template<typename T>
	operator T&()
	{
		static_assert(sizeof(T) == size, "Opaque type delcared with size that does not match the type used to access it.");
		static_assert(align >= alignof(T) && (align % alignof(T) == 0), "Opaque type definition does not match alignment requirements of the type used to access it.");
		return *reinterpret_cast<T*>(&m_ptr);
	}

	template<typename T>
	operator T const&() const
	{
		static_assert(sizeof(T) == size, "Opaque type delcared with size that does not match the type used to access it.");
		static_assert(align >= alignof(T) && (align % alignof(T) == 0), "Opaque type definition does not match alignment requirements of the type used to access it.");
		return *reinterpret_cast<T*>(&m_ptr);
	}

private:
	typename std::aligned_storage<size, align>::type m_ptr;
	typename std::aligned_storage<sizeof(Deleter), alignof(Deleter)>::type m_deleter;
};