/*

* 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 "CMSRPMessageHandler.h"

// INCLUDES

#include <e32math.h>

#include <s32mem.h>

#include "MMSRPWriterObserver.h"

#include "CMSRPMessage.h"

#include "CMSRPResponse.h"

#include "CMSRPByteRangeHeader.h"

#include "CMSRPToPathHeader.h"

#include "CMSRPFromPathHeader.h"

#include "CMSRPMessageIdHeader.h"

#include "CMSRPSuccessReportHeader.h"

#include "CMSRPFailureReportHeader.h"

#include "CMSRPContentTypeHeader.h"

#include "MSRPStrings.h"

#include "MsrpStrConsts.h"

#include "TMSRPUtil.h"

#include "MMSRPConnection.h"

#include "MMSRPMessageObserver.h"

// Constants

const TInt KEndlineConstLength = 10;

TInt CMSRPMessageHandler::LinkOffset()

    {

    return _FOFF(CMSRPMessageHandler,iLink);

    }

// -----------------------------------------------------------------------------

// CMSRPMessageHandler::NewL

// -----------------------------------------------------------------------------

//

CMSRPMessageHandler* CMSRPMessageHandler::NewL( MMSRPMessageObserver* aMessageObserver, const TDesC8& aMessage )

    {    

    CMSRPMessageHandler* self = CMSRPMessageHandler::NewLC( aMessageObserver, aMessage );

    CleanupStack::Pop( self );

    return self;

    }

CMSRPMessageHandler* CMSRPMessageHandler::NewL( TMSRPMessageType aMessageType )

    {

    CMSRPMessageHandler* self = CMSRPMessageHandler::NewLC( aMessageType );

    CleanupStack::Pop( self );

    return self;

    }

// -----------------------------------------------------------------------------

// CMSRPMessageHandler::NewLC

// -----------------------------------------------------------------------------

//

CMSRPMessageHandler* CMSRPMessageHandler::NewLC( MMSRPMessageObserver* aMessageObserver, const TDesC8& aMessage )

    {    

    CMSRPMessageHandler* self = new (ELeave) CMSRPMessageHandler( aMessageObserver );

    CleanupStack::PushL( self );

    self->ConstructL( aMessage );

    return self;

    }

CMSRPMessageHandler* CMSRPMessageHandler::NewLC( TMSRPMessageType aMessageType )

    {

    CMSRPMessageHandler* self = new (ELeave) CMSRPMessageHandler();

    CleanupStack::PushL( self );

    self->ConstructL( aMessageType );

    return self;

    }

// -----------------------------------------------------------------------------

// CMSRPMessageHandler::ConstructL

// -----------------------------------------------------------------------------

//

void CMSRPMessageHandler::ConstructL( const TDesC8& aMessage )

    {

    MSRPLOG( "CMSRPMessageHandler::ConstructL enter" )

    RDesReadStream readStream( aMessage );

    if ( CMSRPMessage::IsMessage( aMessage ) )

        {

        iMessage = CMSRPMessage::InternalizeL( readStream );

        if( iMessage->IsContent() )

            {

            iContentPtr.Set(iMessage->Content());

            }

        }    

    else

        {

        User::Leave( KErrArgument );

        }

    iBuffer.CreateL( KMaxBufferSize );

    iState = EIdle;

    MSRPStrings::OpenL();

    MSRPLOG( "CMSRPMessageHandler::ConstructL exit" )

    }

void CMSRPMessageHandler::ConstructL( TMSRPMessageType aMessageType )

    {

    MSRPLOG2( "CMSRPMessageHandler::ConstructL enter - MessageType %d", aMessageType )

    if( aMessageType == EMSRPMessage )

        {

        iMessage = new ( ELeave ) CMSRPMessage();

        }

    else if( aMessageType == EMSRPResponse )

        {

        iResponse = new ( ELeave ) CMSRPResponse();

        }

    else if( aMessageType == EMSRPReport )

        {

        // Since Reports are not supported now.. jus create a message class

        }

    else

        {

        // Maybe AUTH or some unrecognized request. For now just create a message class

        iMessage = new ( ELeave ) CMSRPMessage();

        }

    iActiveMsgType = aMessageType;

    iBuffer.CreateL( KSmallBuffer );

    iState = EIdle;    

    MSRPStrings::OpenL();

    MSRPLOG( "CMSRPMessageHandler::ConstructL exit" )

    }

// -----------------------------------------------------------------------------

// Constructor

// -----------------------------------------------------------------------------

//

CMSRPMessageHandler::CMSRPMessageHandler( MMSRPMessageObserver* aMessageObserver )

    {

    iMSRPMessageObserver = aMessageObserver;

    }

CMSRPMessageHandler::CMSRPMessageHandler( )

    {

    }

// -----------------------------------------------------------------------------

// Destructor

// -----------------------------------------------------------------------------

//

CMSRPMessageHandler::~CMSRPMessageHandler( )

    {

    delete iMessage;

    delete iResponse;

    delete iFileBuffer;

    iBuffer.Close();

    MSRPStrings::Close();

    iFile.Close();

    }

void CMSRPMessageHandler::AddHeaderL( TMsrpHeaderType aHeaderType, TPtrC8& aHeaderValue, TPtrC8& /*aHeaderTypeAndValue*/ )

    {

    MSRPLOG( "CMSRPMessageHandler::AddHeaderL enter" )

    CMSRPMessageBase* messageBase = NULL;

    if( iResponse )

        {

        messageBase = iResponse;

        }

    else

        {

        messageBase = iMessage;

        }

    TInt err = KErrNone;

    switch( aHeaderType )

        {

        case EToPath:        

            {

            messageBase->SetToPathHeader( CMSRPToPathHeader::DecodeL( aHeaderValue ) );

            break;

            }

        case EFromPath:      

            {

            messageBase->SetFromPathHeader( CMSRPFromPathHeader::DecodeL( aHeaderValue ) );

            break;

            }

        case EMessageId:     

            {

            messageBase->SetMessageIdHeader( CMSRPMessageIdHeader::NewL( aHeaderValue ) );

            break;

            }

        case EByteRange:     

            {

            TInt startPos(0);

            TInt endPos(0);

            TInt total(0); 

            err =  ExtractByteRangeParams( aHeaderValue, startPos, endPos, total );

            messageBase->SetByteRangeHeader( CMSRPByteRangeHeader::NewL( startPos, endPos, total ));

            break;

            }

        case ESuccessReport: 

            {

            if( aHeaderValue == MSRPStrings::StringF( MSRPStrConsts::EYes ).DesC())

                {

                messageBase->SetSuccessReportHeader( 

                        CMSRPSuccessReportHeader::NewL( MSRPStrings::StringF( MSRPStrConsts::EYes ) ) );

                }

            else if( aHeaderValue == MSRPStrings::StringF( MSRPStrConsts::ENo ).DesC())

                {

                messageBase->SetSuccessReportHeader( 

                        CMSRPSuccessReportHeader::NewL( MSRPStrings::StringF( MSRPStrConsts::ENo ) ) );

                }  

            else

                {

                err = KErrArgument;

                }

            break;

            }                

        case EFailureReport: 

            {

            if( aHeaderValue == MSRPStrings::StringF( MSRPStrConsts::EYes ).DesC())

                {

                messageBase->SetFailureReportHeader( 

                        CMSRPFailureReportHeader::NewL( MSRPStrings::StringF( MSRPStrConsts::EYes ) ) );

                }

            else if( aHeaderValue == MSRPStrings::StringF( MSRPStrConsts::ENo ).DesC())

                {

                messageBase->SetFailureReportHeader( 

                        CMSRPFailureReportHeader::NewL( MSRPStrings::StringF( MSRPStrConsts::ENo ) ) );

                }

            else if( aHeaderValue == MSRPStrings::StringF( MSRPStrConsts::EPartial ).DesC())

                {

                messageBase->SetFailureReportHeader( 

                        CMSRPFailureReportHeader::NewL( MSRPStrings::StringF( MSRPStrConsts::EPartial ) ) );

                }

            else

                {

                err = KErrArgument;

                }

            break;

            }                

        case EContentType:   

            {

            messageBase->SetContentTypeHeader( CMSRPContentTypeHeader::NewL( aHeaderValue ) );

            break;

            }                

        case EStatus:        

            {

            break; // required for reports only. Not handled now

            }              

        default:             

            {

            break;

            }                   

        }

    User::LeaveIfError(err);

    MSRPLOG( "CMSRPMessageHandler::AddHeaderL exit" )

    }

    {

    if( iMessage )

        {

            {

            }

        else

            {

            }

        }    

    MSRPLOG( "CMSRPMessageHandler::AddContentL exit" )

    }

    {

    MSRPLOG( "CMSRPMessageHandler::SetTransactionId exit" )

    }

void CMSRPMessageHandler::SetStatusOfResponseL( TPtrC8& aStatusCode, TPtrC8& /*aStatusMessage*/ )

    {

    MSRPLOG( "CMSRPMessageHandler::SetStatusOfResponseL enter" )

    if( iResponse )

        {

        TUint statusCodeVal = TMSRPUtil::ConvertToNumber( aStatusCode );

        RStringF statusString = GetStatusStringL( statusCodeVal );                        

        iResponse->SetStatusCodeL( statusCodeVal );

        iResponse->SetReasonPhrase( statusString );

        }    

    MSRPLOG( "CMSRPMessageHandler::SetStatusOfResponseL exit" )

    }

void CMSRPMessageHandler::EndOfMessageL( TMsrpMsgEndStatus aStatus )

    {

        {

        }

    MSRPLOG( "CMSRPMessageHandler::EndOfMessageL exit" )

    }

MMSRPIncomingMessage::TMSRPMessageType CMSRPMessageHandler::MessageType( )

    {

    MSRPLOG( "CMSRPMessageHandler::MessageType enter" )

    MSRPLOG2("Message Type = %d", iActiveMsgType ); 

    return iActiveMsgType;

    }

    {

    MSRPLOG( "CMSRPMessageHandler::GetIncomingMessage enter" )  

    }

                                            MMSRPConnection& aConnection, TUint aResponseCode )

    {

    MSRPLOG( "CMSRPMessageHandler::SendResponseL enter" )

    iMSRPMessageObserver = aMessageObserver;

    if( !aResponseCode )

        {

        aResponseCode = CheckValidityOfMessage( EMSRPMessage, iMessage );

        }

    TBool sendResponse = ETrue;

    if( iMessage->FailureReportHeader() )

        {

        HBufC8* frHeaderValue = iMessage->FailureReportHeader()->ToTextValueLC();

        if( frHeaderValue->Des() == MSRPStrings::StringF( MSRPStrConsts::ENo ).DesC() )

            {

            sendResponse = EFalse;

            }

        else if( (frHeaderValue->Des() == MSRPStrings::StringF( MSRPStrConsts::EPartial ).DesC()) 

            {

            sendResponse = EFalse;

            }

        CleanupStack::PopAndDestroy(frHeaderValue);

        }

    if( !iMessage->ToPathHeader() || !iMessage->FromPathHeader() )

        {

        sendResponse = EFalse;

        }

    if(sendResponse)

        {

        RStringF statusString = GetStatusStringL( aResponseCode );

        iResponse = new ( ELeave ) CMSRPResponse( aResponseCode, statusString ) ;

        HBufC8* fromPathValue = iMessage->FromPathHeader()->ToTextValueLC();

        iResponse->SetToPathHeader( CMSRPToPathHeader::DecodeL( *fromPathValue ) );

        CleanupStack::PopAndDestroy(fromPathValue);

        HBufC8* toPathValue = iMessage->ToPathHeader()->ToTextValueLC();

        iResponse->SetFromPathHeader( CMSRPFromPathHeader::DecodeL( *toPathValue ) );

        iActiveMsgType = EMSRPResponse;

        aConnection.SendL( *this );

        }

    MSRPLOG( "CMSRPMessageHandler::SendResponseL exit" )

    }

    {

        {

            {

            }

        }