#pragma once

#include "KObject.h"
#include "SContentsManager.h"
#include "SGameMessage.h"
//#include "SGameMessageUI.h"

struct SGameMessage;

class SGuiObj
{
public:
	SGuiObj( SIMSG_TOGGLE_UIWINDOW::_UIWINDOW_TYPE objId );
	KObject* operator -> ();
	operator bool () const;
private:
	SIMSG_TOGGLE_UIWINDOW::_UIWINDOW_TYPE mObjId;
	KObject* mObj;
	static KObject mNull;
};

class IContents : public KObject
{
public:
	IContents( const char* name, SContentsManager& contentsMgr )
		: mName( name )
		, mContentsMgr( contentsMgr )
	{
		mContentsMgr._addContents( mName.c_str(), *this );
	}
	virtual ~IContents()
	{
		mContentsMgr._rmvContents( mName.c_str() );
	}
	virtual void process( DWORD time ) = 0;
	virtual void notifyMsg( SGameMessage* msg ) = 0;

protected:
	const std::string mName;
	SContentsManager& mContentsMgr;
};

template< typename T >
class SMsgMapper
{
public:
	typedef void ( T::*MsgProcFn )( SGameMessage* );
	typedef std::map< int, MsgProcFn > MsgMap;

	virtual ~SMsgMapper() {}
	void mapProc( const int msgId, MsgProcFn fn )
	{
		mMsgMap[ msgId ] = fn;
	}
	void executeFn( const int msgId, SGameMessage* msg )
	{
		MsgMap::iterator found = mMsgMap.find( msgId );
		if( found != mMsgMap.end() )
		{
			MsgProcFn fn = found->second;
			T* instance = static_cast< T* >( this );
			( instance->*fn )( msg );
		}
	}

protected:
	MsgMap mMsgMap;
};

template< typename T >
class SContents : public IContents, public SMsgMapper< T >
{
public:
	SContents( const char* name, SContentsManager& contentsMgr );
	virtual ~SContents();
	virtual void process( DWORD time ) {}
	virtual void notifyMsg( SGameMessage* msg );

protected:
	void defMsgProc( const int msg, MsgProcFn fn );
	void cleanMsg();
};

template< typename T > SContents< T >::SContents( const char* name, SContentsManager& contentsMgr ) 
: IContents( name, contentsMgr )
{
}

template< typename T > SContents< T >::~SContents()
{
	cleanMsg();
}

template< typename T > void SContents< T >::notifyMsg( SGameMessage* msg )
{
	executeFn( msg->nType, msg );
}

template< typename T > void SContents< T >::defMsgProc( const int msgId, MsgProcFn fn )
{
	mContentsMgr.registerMsgObserver( msgId, *this );
	mapProc( msgId, fn );
}

template< typename T > void SContents< T >::cleanMsg()
{
	if( mMsgMap.empty() )
		return;

	MsgMap::iterator it = mMsgMap.begin(), end = mMsgMap.end();

	for( ; it != end; ++it )
		mContentsMgr.deregisterMsgObserver( it->first, *this );
}