/*

* 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 "CMSRPReport.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"

#include "CMSRPStatusHeader.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 if ( CMSRPReport::IsReport( aMessage ) )

        {

        iReport = CMSRPReport::InternalizeL( readStream );

        }

    else

        {

        User::Leave( KErrArgument );

        }

    iBuffer.CreateL( KMaxBufferSize );

    iState = EIdle;

    MSRPStrings::OpenL();

    iFs.Connect();

    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

        iReport = new ( ELeave ) CMSRPReport();            

        }

    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();

    iFs.Connect();

    MSRPLOG( "CMSRPMessageHandler::ConstructL exit" )

    }

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

// Constructor

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

//

CMSRPMessageHandler::CMSRPMessageHandler( MMSRPMessageObserver* aMessageObserver )

    {

    iMSRPMessageObserver = aMessageObserver;

    }

CMSRPMessageHandler::CMSRPMessageHandler( )

    {

    }

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

// Destructor

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

//

CMSRPMessageHandler::~CMSRPMessageHandler( )

    {

    MSRPLOG2( "-> CMSRPMessageHandler::~CMSRPMessageHandler = %d", this )

    delete iMessage;

    delete iResponse;

    delete iFileBuffer;

    iSentChunks.ResetAndDestroy();

    iSentChunks.Close();

    iBuffer.Close();

    MSRPStrings::Close();

    iFile.Close();

    MSRPLOG( "<- CMSRPMessageHandler::~CMSRPMessageHandler" )

    }

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

    {

    MSRPLOG( "CMSRPMessageHandler::AddHeaderL enter" )

    CMSRPMessageBase* messageBase = NULL;

    if( iResponse )

        {

        messageBase = iResponse;

        }

    else if ( iReport )

        {

        messageBase = iReport;

        }

    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:        

            {

            TInt statusValue = TMSRPUtil::ConvertToNumber( aHeaderValue );

            messageBase->SetStatusHeader( CMSRPStatusHeader::NewL( statusValue ) );

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

            }              

        default:             

            {

            break;

            }                   

        }

    User::LeaveIfError(err);

    MSRPLOG( "CMSRPMessageHandler::AddHeaderL exit" )

    }

void CMSRPMessageHandler::AddContentL( TPtrC8& aContent, TBool aByteRangeFound )

    {

    MSRPLOG2( "CMSRPMessageHandler::AddContentL enter, instance = %d", this )

    if( iMessage )

        {

        if ( aByteRangeFound )

            {

            if( iBuffer.Length() + aContent.Length() > iBuffer.MaxLength() )

                {

                HBufC8* combined = HBufC8::NewLC( iBuffer.Length() + aContent.Length() );

                TPtr8 ptr = combined->Des();

                ptr = iBuffer;

                ptr.Append( aContent );

                // must write to file

                WriteMessageToFileL( ptr );

                CleanupStack::PopAndDestroy( ); // combined

                iBuffer.Zero();

                }

            else

                {

                iBuffer.Append( aContent );

                iCurrentNumberOfBytes = iBuffer.Length();

                }

            }

        else

            {

            AppendMessageToFileL( aContent );

            }

        }    

    MSRPLOG( "CMSRPMessageHandler::AddContentL exit" )

    }

void CMSRPMessageHandler::SetTransactionId( TDesC8& aTransactionId )

    {

    MSRPLOG( "CMSRPMessageHandler::SetTransactionId enter" )

    HBufC8* transactionId = HBufC8::NewL( aTransactionId.Length() );

    *transactionId = aTransactionId;

    iSentChunks.Append( transactionId );

    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 )

    {

    MSRPLOG2( "CMSRPMessageHandler::EndOfMessageL enter = %d", this )

    MSRPLOG2( "CMSRPMessageHandler::EndOfMessageL enter = %d", aStatus )

    iMessageEnding = aStatus;

    if( iMessage && iBuffer.Length() && ( aStatus == EMessageEnd ) )

        {

        if ( !iTempFileName.Length() )

            {

            HBufC8* contentOfMessage = HBufC8::NewL( iBuffer.Length() );

            *contentOfMessage = iBuffer;

            iMessage->SetContent( contentOfMessage );

            iBuffer.Zero();

            }

        else

            {

            WriteMessageToFileL( iBuffer );

            iBuffer.Zero();

            }

        }

    if ( aStatus == EMessageEnd )

        {

        iState = EMessageDone;

        }

    if( aStatus == EMessageTerminated )

        {

        iTerminateReceiving = ETrue;

        iState = ETerminated;

        }

    MSRPLOG( "CMSRPMessageHandler::EndOfMessageL exit" )

    }

MMSRPIncomingMessage::TMSRPMessageType CMSRPMessageHandler::MessageType( )

    {

    MSRPLOG( "CMSRPMessageHandler::MessageType enter" )

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

    return iActiveMsgType;

    }

CMSRPMessage* CMSRPMessageHandler::GetIncomingMessage( ) const

    {

    MSRPLOG( "CMSRPMessageHandler::GetIncomingMessage enter" )  

    return iMessage;

    }

void CMSRPMessageHandler::SendResponseL( MMSRPMessageObserver* aMessageObserver, 

                                            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()) 

                && (aResponseCode == EAllOk) )

            {

            sendResponse = EFalse;

            }

        CleanupStack::PopAndDestroy(frHeaderValue);

        }

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

        {

        aResponseCode = EUnknownCode;

        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 ) );

        CleanupStack::PopAndDestroy(toPathValue);   

        iActiveMsgType = EMSRPResponse;

        iState = EIdle;

        aConnection.SendL( *this );

        }

    MSRPLOG( "CMSRPMessageHandler::SendResponseL exit" )

    }

TBool CMSRPMessageHandler::SendReportL( 

    MMSRPMessageObserver* aMessageObserver, 

    MMSRPConnection& aConnection, TUint aStatusCode )

    {

    MSRPLOG( "CMSRPMessageHandler::SendReportL enter" )

    TBool sendReport = EFalse;

    if ( iActiveMsgType == EMSRPResponse )

        {

        // currently sending a response

        MSRPLOG( "CMSRPMessageHandler::SendReportL sendin a response..." )

        return sendReport;

        }

    iMSRPMessageObserver = aMessageObserver;

    if( iMessage->SuccessReportHeader() )

        {

        HBufC8* successHeaderValue = iMessage->SuccessReportHeader()->ToTextValueLC();

        if( successHeaderValue->Des() == MSRPStrings::StringF( MSRPStrConsts::EYes ).DesC() )

            {

            MSRPLOG( "CMSRPMessageHandler::SendReportL report needed!" )

            sendReport = ETrue;

            }

        CleanupStack::PopAndDestroy( successHeaderValue );

        }

    if ( sendReport )

        {

        iReport = new ( ELeave ) CMSRPReport( ) ;

        iReport->SetStatusHeader( CMSRPStatusHeader::NewL( aStatusCode ) );

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

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

        CleanupStack::PopAndDestroy(fromPathValue);

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

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

        CleanupStack::PopAndDestroy(toPathValue);   

        HBufC8* messageId = iMessage->MessageIdHeader()->ToTextValueLC();

        iReport->SetMessageIdHeader( CMSRPMessageIdHeader::NewL( *messageId ) );

        CleanupStack::PopAndDestroy( messageId );   

        TInt size( 0 );

        if ( iTempFileName.Length() )

            {

            OpenTemporaryFileL( iTempFileName );

            iTempFile->Size( size );

            }

        else

            {

            size = iBuffer.Length();

            }

        CMSRPByteRangeHeader* byteRange = 

                CMSRPByteRangeHeader::NewL( 1, size, size );

        iReport->SetByteRangeHeader( byteRange );

        iActiveMsgType = EMSRPReport;

        iState = EIdle;