/*
* 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
*
*/

// CLASS HEADER
#include "CMsrpMessage.h"

// EXTERNAL INCLUDES
#include <MsrpStrConsts.h>

// INTERNAL INCLUDES
#include "MsrpCommon.h"
#include "CMSRPFromPathHeader.h"
#include "CMSRPToPathHeader.h"
#include "CMSRPMessageIdHeader.h"
#include "CMSRPByteRangeHeader.h"
#include "CMSRPContentTypeHeader.h"
#include "CMSRPFailureReportHeader.h"
#include "CMSRPSuccessReportHeader.h"
#include "TMSRPHeaderUtil.h"
// -----------------------------------------------------------------------------
// CMSRPMessage::CMSRPMessage
// -----------------------------------------------------------------------------
//
EXPORT_C CMSRPMessage::CMSRPMessage()
	{
	}

// -----------------------------------------------------------------------------
// CMSRPMessage::~CMSRPMessage
// -----------------------------------------------------------------------------
//
EXPORT_C CMSRPMessage::~CMSRPMessage()
	{
	delete iContentBuffer;
	}

// -----------------------------------------------------------------------------
// CMSRPMessage::SetContentL
// -----------------------------------------------------------------------------
//
EXPORT_C void CMSRPMessage::SetContent( HBufC8* aContent )
	{
    if( iContentBuffer )
        {
        delete iContentBuffer;
        iContentBuffer = NULL;
        }
	iContentBuffer = aContent;
	}

// -----------------------------------------------------------------------------
// CMSRPMessage::Content
// -----------------------------------------------------------------------------
//
EXPORT_C const TDesC8& CMSRPMessage::Content( )
	{
    if( iContentBuffer )
        {
        return *iContentBuffer;
        }
	return KNullDesC8();
	}

// -----------------------------------------------------------------------------
// CMSRPMessage::IsContent
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CMSRPMessage::IsContent( ) const
	{
	if ( iContentBuffer )
		{
		return ETrue;
		}

	return EFalse;
	}

// -----------------------------------------------------------------------------
// CMSRPMessage::SetFileName
// -----------------------------------------------------------------------------
//
EXPORT_C void CMSRPMessage::SetFileName( const TFileName& aFileName )
    {
    iFileName = aFileName;
    }

// -----------------------------------------------------------------------------
// CMSRPMessage::GetFileName
// -----------------------------------------------------------------------------
//
EXPORT_C TFileName& CMSRPMessage::GetFileName( )
    {
    return iFileName;
    }

// -----------------------------------------------------------------------------
// CMSRPMessage::InternalizeL
// -----------------------------------------------------------------------------
//
EXPORT_C CMSRPMessage* CMSRPMessage::InternalizeL( RReadStream& aReadStream )
	{
	CMSRPMessage* self = new (ELeave) CMSRPMessage();
	CleanupStack::PushL( self );
    self->DoInternalizeL( aReadStream );
	CleanupStack::Pop( self );
    return self;
	}

// -----------------------------------------------------------------------------
// CMSRPMessage::DoInternalizeL
// -----------------------------------------------------------------------------
//
void CMSRPMessage::DoInternalizeL( RReadStream& aReadStream )
    {
    TUint8 dataType( 0 );

    // read the identifier
    if ( aReadStream.ReadUint8L() != 100 )
        {
        User::Leave( KErrArgument );
        }

    do
        {
        dataType = aReadStream.ReadUint8L();

        switch( dataType )
            {
            case 1: // from path
                {
                iFromPath = CMSRPFromPathHeader::InternalizeValueL( aReadStream );
                break;
                }
            case 2: // to path
                {
                iToPath = CMSRPToPathHeader::InternalizeValueL( aReadStream );
                break;
                }
            case 3: // message id
                {
                iMessageId = CMSRPMessageIdHeader::InternalizeValueL( aReadStream );
                break;
                }
            case 4: // byte range
                {
                iByteRange = CMSRPByteRangeHeader::InternalizeValueL( aReadStream );
                break;
                }
            case 5: // content type
                {
                iContentType = CMSRPContentTypeHeader::InternalizeValueL( aReadStream );
                break;
                }
            case 6: // failure report
                {
                iFailureReport = CMSRPFailureReportHeader::InternalizeValueL( aReadStream );
                break;
                }
            case 7: // success report
                {
                iSuccessReport = CMSRPSuccessReportHeader::InternalizeValueL( aReadStream );
                break;
                }
            case 10: // content buffer
                {
                TUint32 contentLength = aReadStream.ReadUint32L();
                iContentBuffer = HBufC8::NewL( contentLength );
                TPtr8 bufferPtr = iContentBuffer->Des();
                aReadStream.ReadL( bufferPtr, contentLength );
                break;
                }
            case 11: //filename
                {
                 TUint32 nameLength = aReadStream.ReadUint32L();
                 aReadStream.ReadL( iFileName, nameLength );
                 break;
                }
                  
            default:
                {
                // nothing to do
                break;
                }
            }

        } while( dataType );
    }
// -----------------------------------------------------------------------------
// CMSRPMessage::ExternalizeL
// -----------------------------------------------------------------------------
//

EXPORT_C void CMSRPMessage::ExternalizeL( RWriteStream& aWriteStream )
        {
        // first add the MSRP Message identifier
        aWriteStream.WriteUint8L( 100 ); // MSRP Message identifier

        if( iFromPath )
            {
            aWriteStream.WriteUint8L(1); // more headers in the stream flag
            iFromPath->ExternalizeValueL( aWriteStream );
            }
        if( iToPath )
            {
            aWriteStream.WriteUint8L(2); // more headers in the stream flag
            iToPath->ExternalizeValueL( aWriteStream );
            }
        if ( iMessageId )
            {
            aWriteStream.WriteUint8L(3); // more headers in the stream flag
            iMessageId->ExternalizeValueL( aWriteStream );
            }
        if( iByteRange )
            {
            aWriteStream.WriteUint8L(4); // more headers in the stream flag
            iByteRange->ExternalizeValueL( aWriteStream );
            }
        if( iContentType )
            {
            aWriteStream.WriteUint8L(5); // more headers in the stream flag
            iContentType->ExternalizeValueL( aWriteStream );
            }
        if( iFailureReport )
            {
            aWriteStream.WriteUint8L(6); // more headers in the stream flag
            iFailureReport->ExternalizeValueL( aWriteStream );
            }
        if( iSuccessReport )
            {
            aWriteStream.WriteUint8L(7); // more headers in the stream flag
            iSuccessReport->ExternalizeValueL( aWriteStream );
            }
        if ( IsFile() )
            {
            aWriteStream.WriteUint8L( 11 ); // 2 = file ID
            aWriteStream.WriteInt32L( iFileName.Length() );
            aWriteStream.WriteL( iFileName );
            }
        if ( IsContent() )
            {
            // let's check if the buffer length is larger than KMaxLengthOfSmallMSRPMessage
            // if so, we must convert buffer to file
            if ( iContentBuffer->Length() > KMaxLengthOfSmallMSRPMessage )
                {
                ConvertBufferToFileL();
                aWriteStream.WriteUint8L( 11 );
                aWriteStream.WriteInt32L( iFileName.Length() );
                aWriteStream.WriteL( iFileName );
                }
            else
                {
                aWriteStream.WriteUint8L( 10 ); 
                aWriteStream.WriteInt32L( iContentBuffer->Length()  );
                aWriteStream.WriteL( *iContentBuffer, iContentBuffer->Length() );
                }
            }
             
        aWriteStream.WriteUint8L(0); // no more headers in the stream flag
        }

// -----------------------------------------------------------------------------
// CMSRPMessage::IsMessage
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CMSRPMessage::IsMessage( const TDesC8& aBuffer )
	{
	if ( aBuffer.Length() )
		{
		if ( aBuffer[ 0 ] == 100 )
			{
			return ETrue;
			}
		}

	return EFalse;
	}

EXPORT_C TBool CMSRPMessage::IsFile()
    {
   if ( iFileName.Length() )
        {
        return ETrue;
        }
    return EFalse;
      
}

// -----------------------------------------------------------------------------
// CMSRPMessage::ConvertBufferToFileL
// -----------------------------------------------------------------------------
//
void CMSRPMessage::ConvertBufferToFileL( )
    {
    RFs fs;
    User::LeaveIfError( fs.Connect() );
    RFile tempFile;
    TFileName tempFileName;

    // create temporary filename
    User::LeaveIfError( tempFile.Temp(
        fs, KDefaultTempFilePath, tempFileName, EFileShareExclusive | EFileWrite ) );

    SetFileName( tempFileName );

    tempFile.Write( 0, *iContentBuffer );
    delete iContentBuffer;
    iContentBuffer = NULL;
    tempFile.Close();
    fs.Close();
    }
      
// End of File