/*
 * Copyright 2015-2018, Dario Casalinuovo. All rights reserved.
 * Distributed under the terms of the MIT License.
 */

#ifndef _MEDIA_SIMPLE_CLIENT_H
#define _MEDIA_SIMPLE_CLIENT_H

#include <MediaClient.h>
#include <MediaConnection.h>


namespace BPrivate { namespace media {


class BSimpleMediaInput;
class BSimpleMediaOutput;

class BSimpleMediaClient : public BMediaClient {
public:
	enum notification {
		B_WILL_START = 1,			// performance_time
		B_WILL_STOP,				// performance_time immediate
		B_WILL_SEEK,				// performance_time media_time

		B_FORMAT_SUGGESTION,		// media_type type, int32 quality,
									// media_format* format
	};

	typedef void					(*notify_hook)(void* cookie,
											notification what,
											...);

									BSimpleMediaClient(const char* name,
										media_type type
											= B_MEDIA_UNKNOWN_TYPE,
										media_client_kinds
											kinds = B_MEDIA_PLAYER
												& B_MEDIA_RECORDER);

	virtual							~BSimpleMediaClient();

	// This is supplied to support generic connections not related
	// to a certain destination or source node, however for various ambiguity
	// reasons we want the BMediaConnection to be declared as input or output.
	// You can pass the object returned by this function to another
	// BMediaClient::Connect(), so that it will automatically connect to this node.
	virtual BSimpleMediaInput*		BeginInput();
	virtual BSimpleMediaOutput*		BeginOutput();

			void					SetHook(notify_hook notifyHook = NULL,
										void* cookie = NULL);

protected:
	virtual void					HandleStart(bigtime_t performanceTime);
	virtual void					HandleStop(bigtime_t performanceTime);

	virtual void					HandleSeek(bigtime_t mediaTime,
										bigtime_t performanceTime);

	virtual status_t				FormatSuggestion(media_type type,
										int32 quality, media_format* format);

private:
			notify_hook				fNotifyHook;
			void*					fNotifyCookie;

	virtual	void					_ReservedSimpleMediaClient0();
	virtual	void					_ReservedSimpleMediaClient1();
	virtual	void					_ReservedSimpleMediaClient2();
	virtual	void					_ReservedSimpleMediaClient3();
	virtual	void					_ReservedSimpleMediaClient4();
	virtual	void					_ReservedSimpleMediaClient5();
			uint32					fPadding[32];
};


class BSimpleMediaConnection : public virtual BMediaConnection {
public:
	enum notification {
		// Inputs
		B_INPUT_CONNECTED = 1,
		B_INPUT_DISCONNECTED,

		B_FORMAT_CHANGED,

		// Outputs
		B_OUTPUT_CONNECTED,
		B_OUTPUT_DISCONNECTED,

		B_PREPARE_TO_CONNECT,	// media_format* format, media_source* source,
								// char* name

		B_FORMAT_PROPOSAL,		// media_format* format
		B_ASK_FORMAT_CHANGE,
	};

	// This function is called when it is the moment to handle a buffer.
	typedef void					(*process_hook)(
										BMediaConnection* connection,
										BBuffer* buffer);

	// Used to notify or inquire the client about what to do when certain
	// events happen.
	typedef status_t				(*notify_hook)(
										BMediaConnection* connection,
										notification what,
										...);

			// Use this to set your callbacks.
			void					SetHooks(process_hook processHook = NULL,
										notify_hook notifyHook = NULL,
										void* cookie = NULL);

			void*					Cookie() const;

	virtual size_t					BufferSize() const;
	virtual void					SetBufferSize(size_t bufferSize);

			// This allow to specify a format that will be used while
			// connecting to another node.
			void					SetAcceptedFormat(
										const media_format& format);
			const media_format&		AcceptedFormat() const;

protected:
									BSimpleMediaConnection(
										media_connection_kinds kinds);
	virtual							~BSimpleMediaConnection();

			// TODO: move those to private and introduce protected methods
			process_hook			fProcessHook;
			notify_hook				fNotifyHook;
			void*					fBufferCookie;

			size_t					fBufferSize;

			media_format			fAcceptedFormat;
};


class BSimpleMediaInput : public BSimpleMediaConnection, public BMediaInput {
public:
									BSimpleMediaInput();

protected:
	virtual							~BSimpleMediaInput();

	virtual status_t				AcceptFormat(media_format* format);

	virtual void					HandleBuffer(BBuffer* buffer);

	virtual void					Connected(const media_format& format);
	virtual void					Disconnected();
};


class BSimpleMediaOutput : public BSimpleMediaConnection, public BMediaOutput {
public:
									BSimpleMediaOutput();

protected:
	virtual							~BSimpleMediaOutput();

	virtual status_t				PrepareToConnect(media_format* format);
	virtual status_t				FormatProposal(media_format* format);

	virtual void					Connected(const media_format& format);
	virtual void					Disconnected();
};


}

}

using namespace BPrivate::media;

#endif