/*

* Copyright (c) 2009-2010 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:

* MSRP Implementation

*

*/

#ifndef CMSRPMESSAGEHANDLER_H_

#define CMSRPMESSAGEHANDLER_H_

// INCLUDES

#include <e32base.h>

#include <f32file.h> 

#include "MSRPCommon.h"

#include "MMSRPMessageHandler.h"

#include "MMSRPIncomingMessage.h"

#include "MMSRPOutgoingMessage.h"

#include "MMSRPWriterObserver.h"

// Forward declarations

class MMSRPMessageHandler;

class MMSRPIncomingMessage;

class MMSRPOutgoingMessage;

class MMSRPWriterObserver;

class MMSRPMessageObserver;

class CMSRPMessage;

class CMSRPResponse;

class CMSRPReport;

class CMSRPMessageBase;

class RStringF;

// Constants

//const TInt KMaxBufferSize = 2500;

const TInt KMaxBufferSize = 10000;

const TInt KSmallBuffer = 1024;

const TInt KMaxChunkReadSize =  65000;

// Class declaration

/*

 * MSRP message handler class. Each MSRP message creates an instance of this class

 * THis class handles both incoming and outgoing messages

 */

class CMSRPMessageHandler : public CBase, public MMSRPMessageHandler, 

                            public MMSRPIncomingMessage, public MMSRPOutgoingMessage, 

                            public MMSRPWriterObserver

    {

    public:

        enum TMSRPMessageState

            {

            EIdle,                // 0

            EInProgress,          // 1

            EChunkSent,           // 2

            EMessageSent,         // 3

            ETerminated ,         // 4

            EWaitingForResponse,  // 5

            EWaitingForReport,    // 6

            EMessageDone          // 7

            };

        /* Two-Phased constructor

         * 

         */

        static CMSRPMessageHandler* NewL( MMSRPMessageObserver* aMessageObserver, 

                const TDesC8& aMessage );

        static CMSRPMessageHandler* NewLC( MMSRPMessageObserver* aMessageObserver, 

                const TDesC8& aMessage );

        static CMSRPMessageHandler* NewL( TMSRPMessageType aMessageType );

        static CMSRPMessageHandler* NewLC( TMSRPMessageType aMessageType );

        /**

         * Destructor.

         */

        ~CMSRPMessageHandler();

        static TInt LinkOffset();		

        TSglQueLink iLink;

        /**

         * Get message id of the current message

         * @return message id of the message, ownership is transferred

         */

        HBufC8* MessageIdLC( ); 

        /**

         * Get currently received bytes in this message handler

         * @param aBytesTransferred number of transferred bytes

         * @param aTotalBytes total size of data

         */

        void CurrentReceiveProgress( TInt& aBytesTransferred, TInt& aTotalBytes ); 

        /**

         * Get currently transferred bytes in this message handler

         * @param aBytesTransferred number of transferred bytes

         * @param aTotalBytes total size of data

         */

        void CurrentSendProgress( TInt& aBytesTransferred, TInt& aTotalBytes ); 

        /**

         * Sets the message observer entoty

         * @param aMessageObserver MMSRPMessageObserver

         */

        void SetMessageObserver( MMSRPMessageObserver* aMessageObserver ); 

        /**

         * Checks whether we are sending or receiving a message with this handler

         * @return true if we are sending a message

         */

        TBool IsSending( ); 

        /**

         * returns the temporary file name

         * @return temporary filename which contains incoming data

         */

        TFileName& TemporaryFileName( ); 

        /**

         * Set the temporary file name. Used when message is divided to multiple chunks

         * @param afilename temporary File name

         */

        void SetTemporaryFileName( TFileName aFileName ); 

        /**

         * Response is no longer needed, it can be deleted

         */

        void ResponseHandled( ); 

        /**

         * Terminates the receiving of message

         * @param aConnection connection instance

         * @param aMessageObserver observer for completed send response

         */

        void TerminateReceiving( MMSRPMessageObserver* aMessageObserver, 

                MMSRPConnection& aConnection );

        /**

         * Terminates the sending of message

         */

        void TerminateSending( );

        /**

         * Returns true if message sending or receiving is terminated

         * @return true if FS is terminated

         */

        TBool IsTransmissionTerminated( );

        /**

         * Returns true if REPORT response was requested

         * @return true if REPORT must be sent

         */

        TBool IsReportNeeded( );

    public: // From base classes

        // From MMSRPWriterObserver

        const TDesC8& GetSendBufferL( TWriteStatus& aStatus, TBool aInterrupt ); 

        MMSRPWriterObserver::TMsgStatus WriteDoneL( TInt aStatus );

        // From MMSRPMessageHandler

        void AddHeaderL( TMsrpHeaderType aHeaderType, TPtrC8& aHeaderValue, 

                TPtrC8& aHeaderTypeAndValue );

        void AddContentL( TPtrC8& aContent, TBool aByteRangeFound = EFalse );

        void SetTransactionId( TDesC8& aTransactionId );

        void SetStatusOfResponseL( TPtrC8& aStatusCode, TPtrC8& aStatusMessage );

        void EndOfMessageL( TMsrpMsgEndStatus aStatus );

        TBool CheckMessageChunkL( CMSRPMessageHandler& aOtherMessage );

    public: // From MMSRPIncomingMessage

        TMSRPMessageType MessageType( );

        CMSRPMessage* GetIncomingMessage( ) const;

        void SendResponseL( MMSRPMessageObserver* aMessageObserver,

                                    MMSRPConnection& aConnection, TUint aResponseCode );

        TBool SendReportL( MMSRPMessageObserver* aMessageObserver, 

                                        MMSRPConnection& aConnection, TUint aStatusCode );

        TDesC8& TransactionId( );

        CMSRPResponse* GetIncomingResponse( ) const;

        CMSRPReport* GetIncomingReport( ) const;

    public: // From MMSRPOutgoingMessage

        void SendMessageL( MMSRPConnection& aConnection );

        TBool IsOwnerOfResponse( MMSRPIncomingMessage& aIncomingMessage );

        TUint ConsumeResponseL( MMSRPIncomingMessage& aIncomingMessage );

        TBool IsMessageComplete();

        TUint GetSendResultL( HBufC8* &aMessageId );

        TBool IsFailureHeaderPartial(); 

    private:

        // Constructor

        CMSRPMessageHandler( MMSRPMessageObserver* aMessageObserver );

        CMSRPMessageHandler( );

        void ConstructL( const TDesC8& aMessage );

        void ConstructL( TMSRPMessageType aMessageType );

        // Member Functions

        void CreateByteRangeHeaderL();

        void CreateTransactionIdL();

        void WriteInitialLineToBufferL();

        void WriteHeadersToBufferL();

        void WriteContentToBuffer();

        void WriteFileContentToBufferL();

        void WriteEndLineToBuffer(TMsrpMsgEndStatus = EMessageEnd );

        TInt ExtractByteRangeParams( TDesC8& aHeaderValue, TInt& aStartPos, 

                TInt& aEndPos, TInt& aTotal );

        RStringF GetStatusStringL( TUint aStatusCode );

        TUint CheckValidityOfMessage( TMSRPMessageType aMessageType, 

                CMSRPMessageBase* aMessage );

        TInt FillFileBufferL();

        /*

        * Opens temporary file. Name of the file is save to iTempFileName

        * and Rfile is in iTempFile

        */

        void CreateTemporaryFileL( );

        /*

        * Opens temporary file. Name of the file is save to iTempFileName

        * and Rfile is in iTempFile

        * @param aFilename filename to open

        */

        void OpenTemporaryFileL( const TDesC& aFilename );

        /*

        * Writes the given buffer to a file

        * @param aBuffer buffer to be written into the file

        */

        void WriteMessageToFileL( TDesC8& aBuffer );

        /*

        * The message continues and a new segment of the message is being

        * written to the end of file. 

        * @param aBuffer buffer to be written into the file

        */

        void AppendMessageToFileL( TDesC8& aBuffer );

    private:

        // Server interface

        MMSRPMessageObserver* iMSRPMessageObserver;

        // array of sent chunks, transaction id is saved from

        // sent chunks

        RPointerArray< HBufC8 > iSentChunks;

        // MSRP Report

        CMSRPReport* iReport;

        // MSRP response;

        CMSRPResponse* iResponse;

        // MSRP message

        CMSRPMessage* iMessage;

        TBool iResponseNeeded;

        RBuf8 iBuffer;

        TPtrC8 iContentPtr;

        TBool iWriteDone;    

        TMSRPMessageType iActiveMsgType;

        TMSRPMessageState iState;

        /* For File Use Case */

        RFile iFile;

        RFs iFs;

        TInt iFileSize;

        TBool isSending;

        TBool iInterrupt;

        HBufC8* iFileBuffer;

        TBool iFileTransferComplete;

        TInt iBufPosInFile; //file buffer start pos in file

        TInt iEndPosInBuffer;    

        TInt iStartPosInBuffer;

        TInt iFileBytesSent;    

        TBool iTerminateReceiving;

        TBool iTerminateSending;

        TInt iNotifiedBytes;

        TInt iPendingBytes;

        /// temporary file name which is used

        TFileName iTempFileName;

        /// file for incoming data, owned

        RFile* iTempFile;

        // number of bytes currently transmitted or received

        TInt iCurrentNumberOfBytes;

        // current message chunk status

        TMsrpMsgEndStatus iMessageEnding;

    };

#endif /* CMSRPMESSAGEHANDLER_H_ */