/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * Additional copyright for this file:
 * Copyright (C) 1999-2000 Revolution Software Ltd.
 * This code is based on source code created by Revolution Software,
 * used with permission.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef ICB_EVENTMANAGER_H_INCLUDED
#define ICB_EVENTMANAGER_H_INCLUDED

// Include files with relative paths
#include "engines/icb/common/px_string.h"
#include "engines/icb/p4.h"
#include "engines/icb/event_timer.h"
#include "engines/icb/event_list.h"
#include "engines/icb/session.h"

namespace ICB {

#define EVENT_MANAGER_LOG "event_manager_log.txt"

// Maximum number of event timers active at one time.
#define EVENT_MANAGER_MAX_TIMERS 4

// Keeps track of which object is interested in hearing about events from which other objects and stores
// events which have occurred until they can be handled.
class _event_manager {
public:
	// Default constructor and destructor.
	_event_manager() {}
	~_event_manager() {}

	// This initializes the whole object and must be called at the start of each session.
	void Initialise();

	// This says whether a particular object has events pending.
	bool8 HasEventPending(int32 nObjectID);

	// This checks if an object has the named event waiting for it.
	bool8 CheckEventWaitingForObject(int32 nObjectID, const char *pcEventName);

	// This shuts down an object in the event manager.
	void ShutDownEventProcessingForObject(int32 nObjectID);

	// This processes the event timers if there are any, posting events as required.
	void CycleEventManager();

	// Determines whether or not the named object is registered for the named event.
	bool8 IsObjectRegisteredForEvent(int32 nCallerID, const char *pcEventName);

	// These functions save and restore necessary parts of the event manager.
	void Save(Common::WriteStream *stream) const;
	void Restore(Common::SeekableReadStream *stream);

	// These functions will probably have direct script counterparts.
	void RegisterForEvent(int32 nObjectID, const char *pcEventName);
	void UnregisterForEvent(int32 nObjectID, const char *pcEventName);
	void PostNamedEvent(const char *pcEventName, int32 nSenderID);
	void PostNamedEventToObject(const char *pcEventName, int32 nTargetID, int32 nSenderID);
	void PostRepeatingEvent(const char *pcEventName, uint32 nStart, uint32 nInterval, uint32 nEnd);
	void ClearAllEventsForObject(int32 nObjectID);
	bool8 DidObjectSendLastNamedEvent(int32 nCallerID, int32 nObjectID, const char *pcEventName) const;
	int32 GetIDOfLastObjectToPostEvent(int32 nCallerID, const char *pcEventName) const;
	void SetSuspendFlagForObject(int32 nObjectID, bool8 bState);

private:
	_event_list m_pEventLists[MAX_session_objects];        // List of objects and the events they are currently interested in.
	_event_timer m_pEventTimers[EVENT_MANAGER_MAX_TIMERS]; // Housekeeping for future and repeating events.
	uint8 m_nNumObjects;                                   // Number of objects in the event manager.
	bool8 m_pbActiveTimers[EVENT_MANAGER_MAX_TIMERS];      // Housekeeping for future and repeating events.
	bool8 m_pbRunning[MAX_session_objects];                // Set true for currently-running objects, false if they have been shut down.
	bool8 m_pbSuspended[MAX_session_objects];              // Allows objects to be suspended then reinstated.

	// Here I block the use of the default '='.
	_event_manager(const _event_manager &) {}
	void operator=(const _event_manager &) {}
};

extern _event_manager *g_oEventManager; // Instantiated in global_objects.cpp.

} // End of namespace ICB

#endif // #if !defined( EVENTMANAGER_H_INCLUDED )