/* 
 * Copyright 2005, Ingo Weinhold, bonefish@users.sf.net. All rights reserved.
 * Distributed under the terms of the MIT License.
 */

#ifndef MESSAGE_DELIVERER_H
#define MESSAGE_DELIVERER_H

#include <Locker.h>
#include <Messenger.h>

struct messaging_target;

// MessagingTargetSet
class MessagingTargetSet {
public:
	virtual ~MessagingTargetSet();

	virtual bool HasNext() const = 0;
	virtual bool Next(port_id &port, int32 &token) = 0;
	virtual void Rewind() = 0;
};

// DefaultMessagingTargetSet
class DefaultMessagingTargetSet : public MessagingTargetSet {
public:
	DefaultMessagingTargetSet(const messaging_target *targets,
		int32 targetCount);
	virtual ~DefaultMessagingTargetSet();

	virtual bool HasNext() const;
	virtual bool Next(port_id &port, int32 &token);
	virtual void Rewind();

private:
	const messaging_target	*fTargets;
	int32					fTargetCount;
	int32					fNextIndex;
};

// SingleMessagingTargetSet
class SingleMessagingTargetSet : public MessagingTargetSet {
public:
	SingleMessagingTargetSet(BMessenger target);
	SingleMessagingTargetSet(port_id port, int32 token);
	virtual ~SingleMessagingTargetSet();

	virtual bool HasNext() const;
	virtual bool Next(port_id &port, int32 &token);
	virtual void Rewind();

private:
	port_id				fPort;
	int32				fToken;
	bool				fAtBeginning;
};

// MessageDeliverer
class MessageDeliverer {
private:
	MessageDeliverer();
	~MessageDeliverer();

	status_t Init();

public:
	static status_t CreateDefault();
	static void DeleteDefault();
	static MessageDeliverer *Default();

	status_t DeliverMessage(BMessage *message, BMessenger target,
		bigtime_t timeout = B_INFINITE_TIMEOUT);
	status_t DeliverMessage(BMessage *message, MessagingTargetSet &targets,
		bigtime_t timeout = B_INFINITE_TIMEOUT);
	status_t DeliverMessage(const void *message, int32 messageSize,
		MessagingTargetSet &targets, bigtime_t timeout = B_INFINITE_TIMEOUT);

private:
	class Message;
	class TargetMessage;
	class TargetMessageHandle;
	class TargetPort;
	struct TargetPortMap;

	TargetPort *_GetTargetPort(port_id portID, bool create = false);
	void _PutTargetPort(TargetPort *port);

	status_t _SendMessage(Message *message, port_id portID, int32 token);

	static int32 _DelivererThreadEntry(void *data);
	int32 _DelivererThread();

	static MessageDeliverer	*sDeliverer;

	BLocker			fLock;
	TargetPortMap	*fTargetPorts;
	thread_id		fDelivererThread;
	volatile bool	fTerminating;
};

#endif	// MESSAGE_DELIVERER_H