// Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
//

#ifndef __CHTTPMESSAGECOMPOSER_H__
#define __CHTTPMESSAGECOMPOSER_H__

#include <e32base.h>
#include <http/mhttpdatasupplier.h>

#include "timerlogger.h"
#include "mhttpbuffersupplier.h"
#include "thttpdatacomposer.h"


class MHttpMessageComposerObserver;

class CHttpMessageComposer : public CActive,
							 public MHttpBufferSupplier
/**	
	The CHttpMessageComposer class provides functionality for creating HTTP/1.1 
	messages as defined in RFC2616. The HTTP/1.1 protocol specifies that the CR
	LF sequence is the end of line (eol) marker for all protocol elements except
	the entity-body.

	The composer does not process any header fields or start-line tokens. 
	Therefore it needs to be told if headers and/or an entity body is expected. 
	If the message does contain an entity body and the size of the body data is
	not known then the composer will apply the chunked transfer encoding to the
	entity body. 

	The composer needs an observer (MHttpMessageComposerObserver). The observer 
	supplies the message info such as the start-line tokens, header field tokens
	and other message info. An MHTTPDataSupplier object is used to supply the 
	entity body data if there is one. The observer must ensure that the 
	descriptors containing the tokens it supplies remain valid until the composer
	notifies it that the message is complete.

	The composer is initially in the Idle state waiting to be notified of 
	available message info. When it is notified, the composer moves into the 
	CreatingStartLine state.

	In the CreatingStartLine state the composer obtains the start-line tokens 
	from the observer. These are added to the current data buffer. The composer
	moves to the CreatingHeaders state.

	In the CreatingHeaders state the composer adds header fields to the current
	data buffer. The observer provides the header field tokens for the field 
	name and field value. The composer will not fold header field values onto 
	multiple lines unless the provided field token already contains folded field
	values. The observer also informs the composer if there is no more header 
	field data. The composer remains in the CreatingHeaders state until there 
	are no more header field values. 
	
	In this case the composer adds an empty line to the current data buffer to 
	mark the end of the header fields section. The current data buffer is ready
	to be sent and the composer informs its observer of this. The composer moves
	into the PendingEntityBody and waits for the observer to notify it that it 
	has finished with the current data buffer.
	
	In the PendingEntityBody state the composer releases the current data buffer.
	It then asks its observer if the message has an entity body. If there is no
	entity body or if it is zero length then the composer moves to PendingIdle 
	state. If there is an entity body and the size is known the composer moves 
	to the SendEntityData state. If the entity body size is unknown the composer
	moves to the CreatingChunkSize state.

	In the SendEntityBody state the composer gets the next entity body data part
	from the data supplier for the entity body. It sets this data as the current
	send buffer and notifies the observer that message data is ready. A check is
	made to see that if the data supplier claims that this is the last data part 
	that all the specified amount of entity body data has been sent. If this is 
	not true the observer will receive an error code of KErrCorrupt. The composer
	moves to PendingReleaseData state and waits for the observer to notify it 
	that it has finished with the current data buffer.

	In the PendingReleaseData state the composer notifies the entity body data
	supplier that it has finished with the current data part. If all the 
	specified entity body data has been sent the composer moves to the 
	PendingIdle state. If there is more entity body data to send the composer
	moves to the SendEntityData and waits for the observer to notify it that 
	there is more message info available.

	In the CreatingChunkSize state the composer adds the size of the following
	chunk-data component to the current send buffer as defined in RFC2616 
	section 3.6.1. The send buffer wil contain the empty line delimiting the 
	previous chunk-data component if this is not the first chunk-size component
	to be sent. The composer notifies its observer that message data is ready. 
	The composer moves into the SendChunkData state and waits for the observer 
	to notify it that it has finished with the current data buffer.

	If the chunk-data is zero-length then the chunk-size component is not added
	to the send buffer.	

	In the SendChunkData state the composer releases the current data buffer. It
	then gets the chunk-data from the data supplier for the entity body. It sets
	this data as the current buffer. The observer is only notified that message 
	data is ready if the chunk-data is not zer-length. The composer moves into 
	the PendingReleaseChunk state and waits for the observer to notify it that 
	it has finished with the current data buffer.

	In the PendingReleaseChunk state the composer notifies the entity body data
	supplier that it has finished with the current data part. If that was the 
	last part of the entity body data the composer adds the last-chunk component
	to the current data buffer. It then asks the observer if the message has any 
	trailer headers. If there are trailer headers then the composer moves to the 
	CreatingTrailers state. Otherwise the composer moves to the 
	CreatingEndOfTrailers state. 
	
	If there is more entity body data to follow the composer moves to the 
	CreatingChunkSize state and waits for the observer to notify it that there is 
	more message info available.

	In the CreatingTrailers state the composer adds trailer header fields to the 
	current data buffer. The observer provides the trailer header field tokens 
	for the field name and field value. The composer will not fold header field 
	values onto multiple lines unless the provided field token already contains 
	folded field values. The observer also informs the composer if the provided 
	field info is for the last trailer header field. The composer remains in the
	CreatingTrailers state until there are no more trailer header field values. 
	
	In this case the composer adds an empty line to the current data buffer to 
	mark the end of the trailer header fields section. The current data buffer 
	is ready to be sent and the composer informs its observer of this. The
	composer moves into the PendingEndOfChunkedBody and waits for the observer 
	to notify it that it has finished with the current data buffer.

	In the PendingEndOfChunkedBody the composer releases the current data buffer
	and moves into the PendingIdle state. 

	In the PendingIdle state the composer informs its observer that the message
	is complete. The composer moves to the Idle state.
	@internalComponent
	@see		MHttpMessageComposerObserver
*/
	{
public:	// methods

	static CHttpMessageComposer* NewL(MHttpMessageComposerObserver& aObserver);
	virtual ~CHttpMessageComposer();
	
	void MessageInfoAvailable();
	void GetMessageData(TPtrC8& aData);
	void ReleaseMessageData();
	void Reset();
	TBool CheckMessagePendingComplete();

private:	// enums

	enum TComposerState
/**	
	The TComposerState enumeration defines the state machine for the http message
	state machine.
*/
		{
		/** The composer is idle.
		*/
		EIdle						= 0,

		/** The start-line is being created. The next state depends on whether 
			there are headers or not.
		*/
		ECreatingStartLine,

		/** The message has header fields. The next header field is added to the
			http message. The composer remains in this state until all the header
			fields have been added. If there is no more header field info an 
			empty line is added. The composer has prepared the first part of the
			http message and can notify its observer that message data is ready.
		*/
		ECreatingHeaders,

		/** The composer needs to decide whether there is entity body and if so
			does it need to be chunk encoded or not.
		*/
		EPendingEntityBody,

		/** The message has a non-encoded entity body. It notifies its observer
			that message data is ready.
		*/
		ESendEntityData,

		/** The composer releases the current entity body data. If all the body
			data has been sent then the message is complete. Otherwise the 
			composer waits to be notified that more entity body data is available.
		*/
		EPendingReleaseData,

		/** There is entity body to sent as in chunk-encoded format. The chunk-
			size component specifying the size of the subsequent chunk-data is
			added to the send buffer. The composer notifies its observer that it
			has message ready. Note the send buffer will contain the empty line
			marking the end of the previous chunk-data if this is not the first
			chunk-size.
		*/
		ECreatingChunkSize,

		/** The chunk-data is ready to be sent. The observer is notified that 
			there is message data ready.
		*/
		ESendChunkData,

		/** The composer releases the current chunk-data. If this was the last
			chunk-data then the composer checks for trailer headers. If there 
			are no trailer then the message is complete, otherwise the trailers
			are added.
		*/
		EPendingReleaseChunk,

		/** The message has trailer header fields. The next trailer header field
			is added to the http message. The composer remains in this state 
			until all the trailer header fields have been added. If there is no 
			more trailer header field info an empty line is added. The composer 
			has prepared the final part of the http message and can notify its 
			observer that message data is ready.
		*/
		ECreatingTrailers,

		/** The composer releases the current data buffer. The observer needs
			to be informed that message is complete.
		*/
		EPendingEndOfChunkedBody,

		/** The message is complete and the composer is waiting to go idle. The
			observer is notified.
		*/
		EPendingIdle
		};

	enum TDataState
/**	
	The TDataState enumeration defines the state of the message parser as 
	regards to the current data packet.
*/
		{
		/**	The composer is waiting for more message info to be available to be
			able to continue composing.
		*/
		EWaitingForInfo			= 0,

		/**	The composer is creating the message from the available info.
		*/
		EGotInfo,

		/** The composer is waiting for the observer to release the current data
			buffer before continuing to compose the message.
		*/
		EWaitingForRelease,

		/**	The composer has been reset.
		*/
		EReset
		};

	enum TComposingStatus
/**	
	The TComposingStatus enumeration defines the status of composing for the 
	current state of the composer.
*/
		{
		/**	The current state has been completed.
		*/
		ESectionDone		= 0,

		/** The current state has not been completed.
		*/
		ESectionNotDone,

		/** The current data packet should be sent.
		*/
		ESendData,

		/** The composer should not continue. Either the message is complete or
			more message info is required to continue.
		*/
		EStop
		};

private:	// methods from CActive

	virtual void RunL();
	virtual void DoCancel();
	virtual TInt RunError(TInt aError);

private:	// methods from MHttpBufferSupplier

	virtual void ReAllocBufferL(TInt aRequiredSize, TPtr8& aBuffer);
	virtual void DeleteBuffer();

private:	// methods

	CHttpMessageComposer(MHttpMessageComposerObserver& aObserver);

	TComposingStatus ComposeStartLineL();
	TComposingStatus ComposeHeadersL();
	TComposingStatus ComposeSingleHeaderL();
	TComposingStatus ComposeChunkSizeL();
	TComposingStatus ComposeLastChunkL();
	TComposingStatus ComposeTrailerL();

	void CompleteSelf();
	void DoReset();

private:	// attributes

	MHttpMessageComposerObserver&	iObserver;
	THttpDataComposer				iDataComposer;
	TComposerState					iState;
	TDataState						iDataState;
	HBufC8*							iDataBuffer;
	TPtrC8							iSendBuffer;
	MHTTPDataSupplier*				iBodyData;
	TInt							iDataSizeLeft;
	TBool							iLastChunk;
	__DECLARE_PERFORMANCE_LOG
	};

#endif	// __CHTTPMESSAGECOMPOSER_H__