/*
 * Copyright 2015, Haiku.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *			Joseph Groover <looncraz@looncraz.net>
*/
#ifndef AS_DELAYED_MESSAGE_H
#define AS_DELAYED_MESSAGE_H


#include <ObjectList.h>
#include <OS.h>


//! Method by which to merge DelayedMessages with the same code.
enum DMMergeMode {
	DM_NO_MERGE			= 0, // Will send this message, and the other(s)
	DM_MERGE_REPLACE	= 1, // Replace older data with newer data
	DM_MERGE_CANCEL		= 2, // keeps older data, cancels this message
	DM_MERGE_DUPLICATES = 3  // If data is the same, cancel new message
};


//! Merge-mode data-matching, set which data must match to merge messages.
enum {
	DM_DATA_DEFAULT	= 0, // Match all for DUPLICATES & none for REPLACE modes.
	DM_DATA_1		= 1 << 0,
	DM_DATA_2		= 1 << 1,
	DM_DATA_3		= 1 << 2,
	DM_DATA_4		= 1 << 3,
	DM_DATA_5		= 1 << 4,
	DM_DATA_6		= 1 << 5
};


//! Convenient delay definitions.
enum {
	DM_MINIMUM_DELAY		= 500ULL,
	DM_SHORT_DELAY			= 1000ULL,
	DM_120HZ_DELAY			= 8888ULL,
	DM_60HZ_DELAY			= 16666ULL,
	DM_MEDIUM_DELAY			= 15000ULL,
	DM_30HZ_DELAY			= 33332ULL,
	DM_15HZ_DELAY			= 66664ULL,
	DM_LONG_DELAY			= 100000ULL,
	DM_QUARTER_SECOND_DELAY	= 250000ULL,
	DM_HALF_SECOND_DELAY	= 500000ULL,
	DM_ONE_SECOND_DELAY		= 1000000ULL,
	DM_ONE_MINUTE_DELAY		= DM_ONE_SECOND_DELAY * 60,
	DM_ONE_HOUR_DELAY		= DM_ONE_MINUTE_DELAY * 60
};


class DelayedMessageData;


/*!	\class DelayedMessage
	\brief Friendly API for creating messages to be sent at a future time.

	Messages can be sent with a relative delay, or at a set time. Messages with
	the same code can be merged according to various rules. Each message can
	have any number of target recipients.

	DelayedMessage is a throw-away object, it is to be created on the stack,
	Flush()'d, then left to be destructed when out of scope.
*/
class DelayedMessage {
	typedef void(*FailureCallback)(int32 code, port_id port, void* data);
public:
								DelayedMessage(int32 code, bigtime_t delay,
									bool isSpecificTime = false);

								~DelayedMessage();

			// At least one target port is required.
			bool				AddTarget(port_id port);

			// Merge messages with the same code according to the following
			// rules and data matching mask.
			void				SetMerge(DMMergeMode mode, uint32 match = 0);

			// Called for each port on which the message was failed to be sent.
			void				SetFailureCallback(FailureCallback callback,
									void* data = NULL);

			template <class Type>
			status_t			Attach(const Type& data);
			status_t			Attach(const void* data, size_t size);

			template <class Type>
			status_t			AttachList(const BObjectList<Type>& list);

			template <class Type>
			status_t			AttachList(const BObjectList<Type>& list,
									bool* whichArray);

			status_t			Flush();

		// Private
			DelayedMessageData*	HandOff();
			DelayedMessageData*	Data() {return fData;}

private:
		// Forbidden methods - these are one time-use objects.
			void*				operator new(size_t);
			void*				operator new[](size_t);

			DelayedMessageData*	fData;
			bool				fHandedOff;
};


// #pragma mark Implementation


template <class Type>
status_t
DelayedMessage::Attach(const Type& data)
{
	return Attach(&data, sizeof(Type));
}


template <class Type>
status_t
DelayedMessage::AttachList(const BObjectList<Type>& list)
{
	if (list.CountItems() == 0)
		return B_BAD_VALUE;

	status_t error = Attach<int32>(list.CountItems());

	for (int32 index = 0; index < list.CountItems(); ++index) {
		if (error != B_OK)
			break;

		error = Attach<Type>(*(list.ItemAt(index)));
	}

	return error;
}


template <class Type>
status_t
DelayedMessage::AttachList(const BObjectList<Type>& list, bool* which)
{
	if (list.CountItems() == 0)
		return B_BAD_VALUE;

	if (which == NULL)
		return AttachList(list);

	int32 count = 0;
	for (int32 index = 0; index < list.CountItems(); ++index) {
		if (which[index])
			++count;
	}

	if (count == 0)
		return B_BAD_VALUE;

	status_t error = Attach<int32>(count);

	for (int32 index = 0; index < list.CountItems(); ++index) {
		if (error != B_OK)
			break;

		if (which[index])
			error = Attach<Type>(*list.ItemAt(index));
	}

	return error;
}


#endif // AS_DELAYED_MESSAGE_H