/*
 * Copyright 2001-2015 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Erik Jaesler, erik@cgsoftware.com
 */
#ifndef _LOOPER_H
#define _LOOPER_H


#include <BeBuild.h>
#include <Handler.h>
#include <List.h>
#include <OS.h>


class BMessage;
class BMessageQueue;
namespace BPrivate {
	class BDirectMessageTarget;
	class BLooperList;
}

// Port (Message Queue) Capacity
#define B_LOOPER_PORT_DEFAULT_CAPACITY	200


class BLooper : public BHandler {
public:
							BLooper(const char* name = NULL,
								int32 priority = B_NORMAL_PRIORITY,
								int32 portCapacity
									= B_LOOPER_PORT_DEFAULT_CAPACITY);
	virtual					~BLooper();

	// Archiving
							BLooper(BMessage* data);
	static	BArchivable*	Instantiate(BMessage* data);
	virtual	status_t		Archive(BMessage* data, bool deep = true) const;

	// Message transmission
			status_t		PostMessage(uint32 command);
			status_t		PostMessage(BMessage* message);
			status_t		PostMessage(uint32 command, BHandler* handler,
								BHandler* replyTo = NULL);
			status_t		PostMessage(BMessage* message, BHandler* handler,
								BHandler* replyTo = NULL);

	virtual	void			DispatchMessage(BMessage* message,
								BHandler* handler);
	virtual	void			MessageReceived(BMessage* message);
			BMessage*		CurrentMessage() const;
			BMessage*		DetachCurrentMessage();
			void			DispatchExternalMessage(BMessage* message,
								BHandler* handler, bool& _detached);
			BMessageQueue*	MessageQueue() const;
			bool			IsMessageWaiting() const;

	// Message handlers
			void			AddHandler(BHandler* handler);
			bool			RemoveHandler(BHandler* handler);
			int32			CountHandlers() const;
			BHandler*		HandlerAt(int32 index) const;
			int32			IndexOf(BHandler* handler) const;

			BHandler*		PreferredHandler() const;
			void			SetPreferredHandler(BHandler* handler);

	// Loop control
	virtual	thread_id		Run();
			void			Loop();
	virtual	void			Quit();
	virtual	bool			QuitRequested();
			bool			Lock();
			void			Unlock();
			bool			IsLocked() const;
			status_t		LockWithTimeout(bigtime_t timeout);
			thread_id		Thread() const;
			team_id			Team() const;
	static	BLooper*		LooperForThread(thread_id thread);

	// Loop debugging
			thread_id		LockingThread() const;
			int32			CountLocks() const;
			int32			CountLockRequests() const;
			sem_id			Sem() const;

	// Scripting
	virtual BHandler*		ResolveSpecifier(BMessage* message, int32 index,
								BMessage* specifier, int32 what,
								const char* property);
	virtual status_t		GetSupportedSuites(BMessage* data);

	// Message filters (also see BHandler).
	virtual	void			AddCommonFilter(BMessageFilter* filter);
	virtual	bool			RemoveCommonFilter(BMessageFilter* filter);
	virtual	void			SetCommonFilterList(BList* filters);
			BList*			CommonFilterList() const;

	// Private or reserved
	virtual status_t		Perform(perform_code d, void* arg);

protected:
		// called from overridden task_looper
			BMessage*		MessageFromPort(bigtime_t = B_INFINITE_TIMEOUT);

private:
	typedef BHandler _inherited;
	friend class BWindow;
	friend class BApplication;
	friend class BMessenger;
	friend class BView;
	friend class BHandler;
	friend class ::BPrivate::BLooperList;
	friend port_id _get_looper_port_(const BLooper* );

	virtual	void			_ReservedLooper1();
	virtual	void			_ReservedLooper2();
	virtual	void			_ReservedLooper3();
	virtual	void			_ReservedLooper4();
	virtual	void			_ReservedLooper5();
	virtual	void			_ReservedLooper6();

							BLooper(const BLooper&);
			BLooper&		operator=(const BLooper&);

							BLooper(int32 priority, port_id port,
								const char* name);

			status_t		_PostMessage(BMessage* msg, BHandler* handler,
								BHandler* reply_to);

	static	status_t		_Lock(BLooper* loop, port_id port,
								bigtime_t timeout);
	static	status_t		_LockComplete(BLooper* loop, int32 old,
								thread_id this_tid, sem_id sem,
								bigtime_t timeout);
			void			_InitData(const char* name, int32 priority,
								port_id port, int32 capacity);
			void			AddMessage(BMessage* msg);
			void			_AddMessagePriv(BMessage* msg);
	static	status_t		_task0_(void* arg);

			void*			ReadRawFromPort(int32* code,
								bigtime_t timeout = B_INFINITE_TIMEOUT);
			BMessage*		ReadMessageFromPort(
								bigtime_t timeout = B_INFINITE_TIMEOUT);
	virtual	BMessage*		ConvertToMessage(void* raw, int32 code);
	virtual	void			task_looper();
			void			_QuitRequested(BMessage* msg);
			bool			AssertLocked() const;
			BHandler*		_TopLevelFilter(BMessage* msg, BHandler* target);
			BHandler*		_HandlerFilter(BMessage* msg, BHandler* target);
			BHandler*		_ApplyFilters(BList* list, BMessage* msg,
								BHandler* target);
			void			check_lock();
			BHandler*		resolve_specifier(BHandler* target, BMessage* msg);
			void			UnlockFully();

			::BPrivate::BDirectMessageTarget* fDirectTarget;
			BMessage*		fLastMessage;
			port_id			fMsgPort;
			int32			fAtomicCount;
			sem_id			fLockSem;
			int32			fOwnerCount;
			thread_id		fOwner;
			thread_id		fThread;
			addr_t			fCachedStack;
			int32			fInitPriority;
			BHandler*		fPreferred;
			BList			fHandlers;
			BList*			fCommonFilters;
			bool			fTerminating;
			bool			fRunCalled;
			bool			fOwnsPort;
			uint32			_reserved[11];
};

#endif	// _LOOPER_H