SHADE_Y3/SHADE_Engine/src/Events/SHEventManager.h

/******************************************************************************
 * \file    SHEventManager.h
 * \author  Loh Xiao Qi
 * \brief   Class declaration for event manager.
 * 
 * \copyright Copyright (c) 2022 Digipen Institute of Technology. Reproduction
 * or disclosure of this file or its contents without the prior written consent
 * of Digipen Institute of Technology is prohibited.
******************************************************************************/
#pragma once

#include "SHEvent.h"
#include "SHEventReceiver.h"
#include <unordered_map>
#include <functional>

/******************************************************************************
	INSTRUCTIONS FOR USE:
	On broadcaster side:
		1. Create a struct/class to contain the data that you would need to send
			 in the event.
		2. Create unique event identifier in SHEventDefines.h, follow the example
			 provided.
		3. When ready to send the event, call
			 SHEventManager::BroadcastEvent<ExampleClass>(exampleClass, EVENT_IDENTIFIER);

		Headers required: SHEventManager.h

	On Receiver side:
		1. Create a function with the signature:
			 SHEventHandle FunctionName(SHEvent);
		2. In the init function of the class, copy the below in and replace the
			 necessary:

			 std::shared_ptr<SHEventReceiverSpec<ReceiverClass>> thisReceiver{
				std::make_shared<SHEventReceiverSpec<ReceiverClass>>(this, &ReceiverClass::ReceiveFunction)
			 };
			 ReceiverPtr receiver = std::dynamic_pointer_cast<SHEventReceiver>(thisReceiver);
			 SHEventManager::SubscribeTo(EVENT_IDENTIFIER, receiver);

		3. Note: The EventIdentifier should match all that is defined in
			 SHEventDefines.h so check there. When the receiver catches the event, it
			 needs to know the struct that the broadcaster is using to cast the void*
			 properly.

		Headers required: SHEventManager.h, SHEventReceiver.h
******************************************************************************/

namespace SHADE
{
	using ResponseFunction = std::function<SHEventHandle(SHEvent)>;
	using ReceiverPtr = std::shared_ptr<SHEventReceiver>;
	using ResponseVec = std::vector<ReceiverPtr>;
	using StaticResponseVec = std::vector<ResponseFunction>;

	using EventManagerListener = std::function<void(SHEvent)>;

	class SHEventManager
	{
	public:

		/****************************************************************************
		 * \param   ListenerConstPtr - Const pointer to listener that sent event.
		 * \param   EventType - Templated type for every type of event

		 * \brief		Receives event from the listeners.
		****************************************************************************/
		static void CatchEvent(SHEvent);

		/****************************************************************************
		 * \param   ResponseFunction - function pointer from receiver to be passed
		 *					into event manager to be called when events are broadcasted.
		 * \param   SHPackageType - package type that corresponding subscriber is
		 *					subscribing to.
		
		 * \brief   Links a function pointer from a subscriber to a particular
		 *					package type
		****************************************************************************/
		static void SubscribeTo(SHEventIdentifier, ReceiverPtr);

		template<typename T>
		static T* BroadcastEvent(T data, SHEventIdentifier eventType);

	private:

		// Registry for broadcasters and subscribers
		static std::unordered_map<SHEventIdentifier,	ResponseVec> packageReceiverRegistry;
		static std::unordered_map<SHEventHandle, SHEventDataPtr> dataEventMap;

		static SHEventHandle handleCounter;

		/****************************************************************************
		 * \param   ListenerConstPtr - Const pointer to listener that sent event.
		 * \param   EventType - Event data

		 * \brief		Broadcast event to all receivers that are subscribed to this
		 *					listener.
		****************************************************************************/
		static void Broadcast(SHEvent const&);

		/****************************************************************************
		 * \param   ReceiverPtr - Pointer to receiver
		 * \param   ListenerConstPtr - Const pointer to listener that receiver is
		 *					subscribing to.

		 * \brief   Registers receiver as a subscriber to listener in the registry.
		****************************************************************************/
		static void RegisterReceiverToType(SHEventIdentifier, ReceiverPtr);

	};

}