#ifndef __MODULEINTERFACE_H
#define __MODULEINTERFACE_H

#include <string>

#include "TypeList.hpp"
   
template< typename Interface, typename CtorParams = NullType >
struct ModuleRegistry;

template< typename Interface>
struct ModuleRegistry< Interface > {
	const char *name;
	void (*initModule)( void *user_data );
	void (*destroyModule)( void *user_data );
	Interface *(*create)( );
	void (*destroy)( Interface *obj );
	
	ModuleRegistry( const char *_name,
		void (*_initModule)( void *user_data ),
		void (*_destroyModule)( void *user_data ),
		Interface *(*_create)( ),
		void (*_destroy)( Interface *obj ) )
		: name( _name ),
		initModule( _initModule ), destroyModule( _destroyModule ),
		create( _create ), destroy( _destroy )
	{
	}
};

template< typename Interface, typename P1 >
struct ModuleRegistry< Interface, TYPELIST_1( P1 ) > {
	const char *name;
	void (*initModule)( void *user_data );
	void (*destroyModule)( void *user_data );
	Interface *(*create)( P1 );
	void (*destroy)( Interface *obj );
	
	ModuleRegistry( const char *_name,
		void (*_initModule)( void *user_data ),
		void (*_destroyModule)( void *user_data ),
		Interface *(*_create)( P1 ),
		void (*_destroy)( Interface *obj ) )
		: name( _name ),
		initModule( _initModule ), destroyModule( _destroyModule ),
		create( _create ), destroy( _destroy )
	{
	}
};	

template< typename Interface, typename P1, typename P2 >
struct ModuleRegistry< Interface, TYPELIST_2( P1, P2 ) > {
	const char *name;
	void (*initModule)( void *user_data );
	void (*destroyModule)( void *user_data );
	Interface *(*create)( P1, P2 );
	void (*destroy)( Interface *obj );
	
	ModuleRegistry( const char *_name,
		void (*_initModule)( void *user_data ),
		void (*_destroyModule)( void *user_data ),
		Interface *(*_create)( P1, P2 ),
		void (*_destroy)( Interface *obj ) )
		: name( _name ),
		initModule( _initModule ), destroyModule( _destroyModule ),
		create( _create ), destroy( _destroy )
	{
	}
};	

template< typename Interface, typename P1, typename P2, typename P3 >
struct ModuleRegistry< Interface, TYPELIST_3( P1, P2, P3 ) > {
	const char *name;
	void (*initModule)( void *user_data );
	void (*destroyModule)( void *user_data );
	Interface *(*create)( P1, P2, P3 );
	void (*destroy)( Interface *obj );
	
	ModuleRegistry( const char *_name,
		void (*_initModule)( void *user_data ),
		void (*_destroyModule)( void *user_data ),
		Interface *(*_create)( P1, P2, P3 ),
		void (*_destroy)( Interface *obj ) )
		: name( _name ),
		initModule( _initModule ), destroyModule( _destroyModule ),
		create( _create ), destroy( _destroy )
	{
	}
};	

template< typename Interface, typename P1, typename P2, typename P3, typename P4 >
struct ModuleRegistry< Interface, TYPELIST_4( P1, P2, P3, P4 ) > {
	const char *name;
	void (*initModule)( void *user_data );
	void (*destroyModule)( void *user_data );
	Interface *(*create)( P1, P2, P3, P4 );
	void (*destroy)( Interface *obj );
	
	ModuleRegistry( const char *_name,
		void (*_initModule)( void *user_data ),
		void (*_destroyModule)( void *user_data ),
		Interface *(*_create)( P1, P2, P3, P4 ),
		void (*_destroy)( Interface *obj ) )
		: name( _name ),
		initModule( _initModule ), destroyModule( _destroyModule ),
		create( _create ), destroy( _destroy )
	{
	}
};	
	
#ifdef SHARED

#ifndef _WIN32
#define DLLEXPORT 
#else
#define DLLEXPORT __declspec( dllexport )
#endif

// no param macro

#define DECLARE_MODULE( baseClass )					\
	extern "C" DLLEXPORT ModuleRegistry<baseClass> registry ## _ ## baseClass;

#define REGISTER_MODULE( name, initModule, destroyModule, baseClass, subClass ) 			\
static baseClass *create( )						\
{									\
	return new subClass( );						\
}									\
									\
static void destroy( baseClass *obj )					\
{									\
	delete obj;							\
}									\
									\
ModuleRegistry<baseClass> registry ## _ ## baseClass( name, initModule, destroyModule, &create, &destroy );

// 1 param macro

#define DECLARE_MODULE_1( baseClass, T1 )				\
	extern "C" DLLEXPORT ModuleRegistry<baseClass, TYPELIST_1( T1 ) > registry ## _ ## baseClass;

#define REGISTER_MODULE_1( name, initModule, destroyModule, baseClass, subClass, T1 ) 		\
static baseClass *create( T1 t1 )					\
{									\
	return new subClass( t1 );					\
}									\
									\
static void destroy( baseClass *obj )					\
{									\
	delete obj;							\
}									\
									\
ModuleRegistry<baseClass, TYPELIST_1( T1 )> registry ## _ ## baseClass( name, initModule, destroyModule, &create, &destroy );

// 2 param macro

#define DECLARE_MODULE_2( baseClass, T1, T2 )				\
	extern "C" DLLEXPORT ModuleRegistry<baseClass, TYPELIST_2( T1, T2 ) > registry ## _ ## baseClass;

#define REGISTER_MODULE_2( name, initModule, destroyModule, baseClass, subClass, T1, T2 ) 		\
static baseClass *create( T1 t1, T2 t2 )				\
{									\
	return new subClass( t1, t2 );					\
}									\
									\
static void destroy( baseClass *obj )					\
{									\
	delete obj;							\
}									\
									\
ModuleRegistry<baseClass, TYPELIST_2( T1, T2 )> registry ## _ ## baseClass( name, initModule, destroyModule, &create, &destroy );

// 3 param macro

#define DECLARE_MODULE_3( baseClass, T1, T2, T3 )			\
	extern "C" DLLEXPORT ModuleRegistry<baseClass, TYPELIST_3( T1, T2, T3 ) > registry ## _ ## baseClass;

#define REGISTER_MODULE_3( name, initModule, destroyModule, baseClass, subClass, T1, T2, T3 )	\
static baseClass *create( T1 t1, T2 t2, T3 t3 )				\
{									\
	return new subClass( t1, t2, t3 );				\
}									\
									\
static void destroy( baseClass *obj )					\
{									\
	delete obj;							\
}									\
									\
ModuleRegistry<baseClass, TYPELIST_3( T1, T2, T3 )> registry ## _ ## baseClass( name, initModule, destroyModule, &create, &destroy );

// 4 param macro

#define DECLARE_MODULE_4( baseClass, T1, T2, T3, T4 )			\
	extern "C" DLLEXPORT ModuleRegistry<baseClass, TYPELIST_4( T1, T2, T3, T4 ) > registry ## _ ## baseClass;

#define REGISTER_MODULE_4( name, initModule, destroyModule, baseClass, subClass, T1, T2, T3, T4 )	\
static baseClass *create( T1 t1, T2 t2, T3 t3, T4 t4 )			\
{									\
	return new subClass( t1, t2, t3, t4 );				\
}									\
									\
static void destroy( baseClass *obj )					\
{									\
	delete obj;							\
}									\
									\
ModuleRegistry<baseClass, TYPELIST_4( T1, T2, T3, T4 )> registry ## _ ## baseClass( name, initModule, destroyModule, &create, &destroy );

#else // SHARED

#define DECLARE_MODULE( baseClass )
#define DECLARE_MODULE_1( baseClass, T1 )
#define DECLARE_MODULE_2( baseClass, T1, T2 )
#define DECLARE_MODULE_3( baseClass, T1, T2, T3 )
#define DECLARE_MODULE_4( baseClass, T1, T2, T3, T4 )

#define REGISTER_MODULE( name, initModule, destroyModule, baseClass, subClass )  \
ModuleRegistry<baseClass> registry ## _ ## baseClass ## _ ## subClass( name, initModule, destroyModule, 0, 0 );

#define REGISTER_MODULE_1( name, initModule, destroyModule, baseClass, subClass, T1 ) \
ModuleRegistry<baseClass, TYPELIST_1( T1 )> registry ## _ ## baseClass ## _ ## subClass( name, initModule, destroyModule, 0, 0 );

#define REGISTER_MODULE_2( name, initModule, destroyModule, baseClass, subClass, T1, T2 ) \
ModuleRegistry<baseClass, TYPELIST_2( T1, T2 )> registry ## _ ## baseClass ## _ ## subClass( name, initModule, destroyModule, 0, 0 );

#define REGISTER_MODULE_3( name, initModule, destroyModule, baseClass, subClass, T1, T2, T3 ) \
ModuleRegistry<baseClass, TYPELIST_3( T1, T2, T3 )> registry ## _ ## baseClass ## _ ## subClass( name, initModule, destroyModule, 0, 0 );

#define REGISTER_MODULE_4( name, initModule, destroyModule, baseClass, subClass, T1, T2, T3, T4 ) \
ModuleRegistry<baseClass, TYPELIST_4( T1, T2, T3, T4 )> registry ## _ ## baseClass ## _ ## subClass( name, initModule, destroyModule, 0, 0 );

#endif // SHARED

#endif // __MODULEINTERFACE_H