// SMLooper.cpp

#include <Message.h>

#include "SMLooper.h"
#include "SMMessages.h"

// SMLooper

// constructor
SMLooper::SMLooper()
		: BLooper(NULL, B_NORMAL_PRIORITY, 1),
		  fUnblockTime(0),
		  fReplyDelay(0),
		  fDeliveryTime(-1),
		  fReplyTime(-1)
{
}

// destructor
SMLooper::~SMLooper()
{
}

// MessageReceived
void
SMLooper::MessageReceived(BMessage *message)
{
	switch (message->what) {
		case MSG_BLOCK:
		{
			bigtime_t now = system_time();
			if (now < fUnblockTime) {
				// port capacity is 1 => the following message blocks the
				// port until return from MessageReceived().
				PostMessage(MSG_UNBLOCK, this);
				snooze_until(fUnblockTime, B_SYSTEM_TIMEBASE);
			}
			break;
		}
		case MSG_UNBLOCK:
			break;
		case MSG_TEST:
			SetDeliveryTime(system_time());
			if (fReplyDelay > 0)
				snooze(fReplyDelay);
			message->SendReply(MSG_REPLY);
			break;
		case MSG_REPLY:
			fReplyTime = system_time();
			break;
		default:
			BLooper::MessageReceived(message);
			break;
	}
}

// BlockUntil
void
SMLooper::BlockUntil(bigtime_t unblockTime)
{
	fUnblockTime = unblockTime;
	PostMessage(MSG_BLOCK, this);
}

// SetReplyDelay
void
SMLooper::SetReplyDelay(bigtime_t replyDelay)
{
	fReplyDelay = replyDelay;
}

// ReplyDelay
bigtime_t
SMLooper::ReplyDelay() const
{
	return fReplyDelay;
}

// DeliverySuccess
bool
SMLooper::DeliverySuccess() const
{
	return (fDeliveryTime >= 0);
}

// SetDeliveryTime
void
SMLooper::SetDeliveryTime(bigtime_t deliveryTime)
{
	fDeliveryTime = deliveryTime;
}

// DeliveryTime
bigtime_t
SMLooper::DeliveryTime() const
{
	return fDeliveryTime;
}

// ReplySuccess
bool
SMLooper::ReplySuccess() const
{
	return (fReplyTime >= 0);
}

// SetReplyTime
void
SMLooper::SetReplyTime(bigtime_t replyTime)
{
	fReplyTime = replyTime;
}

// ReplyTime
bigtime_t
SMLooper::ReplyTime() const
{
	return fReplyTime;
}


// SMHandler

// constructor
SMHandler::SMHandler()
		 : BHandler()
{
}

// MessageReceived
void
SMHandler::MessageReceived(BMessage *message)
{
	switch (message->what) {
		case MSG_TEST:
			if (SMLooper *looper = dynamic_cast<SMLooper*>(Looper())) {
				looper->SetDeliveryTime(system_time());
				if (looper->ReplyDelay() > 0)
					snooze(looper->ReplyDelay());
			}
			message->SendReply(MSG_REPLY);
			break;
		case MSG_REPLY:
			if (SMLooper *looper = dynamic_cast<SMLooper*>(Looper()))
				looper->SetReplyTime(system_time());
			break;
		default:
			BHandler::MessageReceived(message);
			break;
	}
}