#pragma once

// Unity native plugin API
// Compatible with C99

#if defined(__CYGWIN32__)
	#define UNITY_INTERFACE_API __stdcall
	#define UNITY_INTERFACE_EXPORT __declspec(dllexport)
#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(_WIN64) || defined(WINAPI_FAMILY)
	#define UNITY_INTERFACE_API __stdcall
	#define UNITY_INTERFACE_EXPORT// __declspec(dllexport) - this is not needed since all exported functions are listed in .def file,
                                  //                         while this header can also be used by
#elif defined(__MACH__) || defined(__ANDROID__) || defined(__linux__) || defined(__QNX__)
	#define UNITY_INTERFACE_API
	#define UNITY_INTERFACE_EXPORT __attribute__((visibility("default")))
#else
	#define UNITY_INTERFACE_API
	#define UNITY_INTERFACE_EXPORT
#endif



// Unity Interface GUID
// Ensures cross plugin uniqueness.
//
// Template specialization is used to produce a means of looking up a GUID from it's payload type at compile time.
// The net result should compile down to passing around the GUID.
//
// UNITY_REGISTER_INTERFACE_GUID should be placed in the header file of any payload definition outside of all namespaces.
// The payload structure and the registration GUID are all that is required to expose the interface to other systems.
struct UnityInterfaceGUID
{
#ifdef __cplusplus
	UnityInterfaceGUID(unsigned long long high, unsigned long long low)
	: m_GUIDHigh(high)
	, m_GUIDLow(low)
	{
	}

	UnityInterfaceGUID(const UnityInterfaceGUID& other)
	{
		m_GUIDHigh = other.m_GUIDHigh;
		m_GUIDLow  = other.m_GUIDLow;
	}

	UnityInterfaceGUID& operator=(const UnityInterfaceGUID& other)
	{
		m_GUIDHigh = other.m_GUIDHigh;
		m_GUIDLow  = other.m_GUIDLow;
		return *this;
	}

	bool Equals(const UnityInterfaceGUID& other)   const { return m_GUIDHigh == other.m_GUIDHigh && m_GUIDLow == other.m_GUIDLow; }
	bool LessThan(const UnityInterfaceGUID& other) const { return m_GUIDHigh < other.m_GUIDHigh || (m_GUIDHigh == other.m_GUIDHigh && m_GUIDLow < other.m_GUIDLow); }
#endif
	unsigned long long m_GUIDHigh;
	unsigned long long m_GUIDLow;
};
#ifdef __cplusplus
inline bool operator==(const UnityInterfaceGUID& left, const UnityInterfaceGUID& right) { return left.Equals(right); }
inline bool operator!=(const UnityInterfaceGUID& left, const UnityInterfaceGUID& right) { return !left.Equals(right); }
inline bool operator< (const UnityInterfaceGUID& left, const UnityInterfaceGUID& right) { return left.LessThan(right); }
inline bool operator> (const UnityInterfaceGUID& left, const UnityInterfaceGUID& right) { return right.LessThan(left); }
inline bool operator>=(const UnityInterfaceGUID& left, const UnityInterfaceGUID& right) { return !operator< (left,right); }
inline bool operator<=(const UnityInterfaceGUID& left, const UnityInterfaceGUID& right) { return !operator> (left,right); }
#else
typedef struct UnityInterfaceGUID UnityInterfaceGUID;
#endif



#define UNITY_GET_INTERFACE_GUID(TYPE) TYPE##_GUID
#define UNITY_GET_INTERFACE(INTERFACES, TYPE) (TYPE*)INTERFACES->GetInterface(UNITY_GET_INTERFACE_GUID(TYPE));

#ifdef __cplusplus
	#define UNITY_DECLARE_INTERFACE(NAME) \
	struct NAME : IUnityInterface

	template<typename TYPE>                                        \
	inline const UnityInterfaceGUID GetUnityInterfaceGUID();       \

	#define UNITY_REGISTER_INTERFACE_GUID(HASHH, HASHL, TYPE)      \
	const UnityInterfaceGUID TYPE##_GUID(HASHH, HASHL);            \
	template<>                                                     \
	inline const UnityInterfaceGUID GetUnityInterfaceGUID<TYPE>()  \
	{                                                              \
	    return UNITY_GET_INTERFACE_GUID(TYPE);                     \
	}
#else
	#define UNITY_DECLARE_INTERFACE(NAME) \
	typedef struct NAME NAME;             \
	struct NAME

	#define UNITY_REGISTER_INTERFACE_GUID(HASHH, HASHL, TYPE) \
	const UnityInterfaceGUID TYPE##_GUID = {HASHH, HASHL};
#endif



#ifdef __cplusplus
struct IUnityInterface
{
};
#else
typedef void IUnityInterface;
#endif



typedef struct IUnityInterfaces
{
	// Returns an interface matching the guid.
	// Returns nullptr if the given interface is unavailable in the active Unity runtime.
	IUnityInterface* (UNITY_INTERFACE_API * GetInterface)(UnityInterfaceGUID guid);

	// Registers a new interface.
	void (UNITY_INTERFACE_API * RegisterInterface)(UnityInterfaceGUID guid, IUnityInterface* ptr);

#ifdef __cplusplus
	// Helper for GetInterface.
	template <typename INTERFACE>
	INTERFACE* Get()
	{
		return static_cast<INTERFACE*>(GetInterface(GetUnityInterfaceGUID<INTERFACE>()));
	}

	// Helper for RegisterInterface.
	template <typename INTERFACE>
	void Register(IUnityInterface* ptr)
	{
		RegisterInterface(GetUnityInterfaceGUID<INTERFACE>(), ptr);
	}
#endif
} IUnityInterfaces;



#ifdef __cplusplus
extern "C" {
#endif

// If exported by a plugin, this function will be called when the plugin is loaded.
//void UNITY_INTERFACE_EXPORT UNITY_INTERFACE_API UnityPluginLoad(IUnityInterfaces* unityInterfaces);
// If exported by a plugin, this function will be called when the plugin is about to be unloaded.
//void UNITY_INTERFACE_EXPORT UNITY_INTERFACE_API UnityPluginUnload();

#ifdef __cplusplus
}
#endif
