/*

* 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

        iMessage = new ( ELeave ) CMSRPMessage();            

        }

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

    iChunkList.ResetAndDestroy();

    iChunkList.Close();

    //iFile.Flush();

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

    }

void CMSRPMessageHandler::AddContentL( TPtrC8& aContent )

    {

    MSRPLOG( "CMSRPMessageHandler::AddContentL enter" )

    if( iMessage )

        {

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

            {

            iBuffer.ReAllocL(iBuffer.Length() + aContent.Length());

            iBuffer.Append(aContent);

            }

        else

            {

            iBuffer.Append(aContent);

            }

        }    

    MSRPLOG( "CMSRPMessageHandler::AddContentL exit" )

    }

void CMSRPMessageHandler::SetTransactionId( TPtrC8& aTransactionId )

    {

    MSRPLOG( "CMSRPMessageHandler::SetTransactionId enter" )    

    iTransactionId = aTransactionId;    

    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 enter" )  

    if( iMessage && iBuffer.Length() )

        {

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

        *contentOfMessage = iBuffer;

        iMessage->SetContent( contentOfMessage );

        iBuffer.Zero();

        }

    iMsgEndStatus = aStatus;    

    MSRPLOG( "CMSRPMessageHandler::EndOfMessageL exit" )

    }

MMSRPIncomingMessage::TMSRPMessageType CMSRPMessageHandler::MessageType( )

    {

    MSRPLOG( "CMSRPMessageHandler::MessageType enter" )

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

    return iActiveMsgType;

    }

CMSRPMessage* CMSRPMessageHandler::GetIncomingMessage( )

    {

    MSRPLOG( "CMSRPMessageHandler::GetIncomingMessage enter" )  

    if( iMessage )

        {

        return iMessage;

        }

    return NULL;

    }

void CMSRPMessageHandler::UpdateResponseStateL(CMSRPMessageHandler *incomingMsgHandler)

    {

    MSRPLOG( "CMSRPMessageHandler::UpdateResponseState enter" )

    TBuf8<100> iTransactionId = incomingMsgHandler->TransactionId();

    for(TInt i=0;i<iChunkList.Count();i++)

       {

        if(iTransactionId == iChunkList[i]->GetTransactionId())

            {

             iChunkList[i]->SetResponseSent(ETrue);

             ReceiveFileStateL(iChunkList[i]->GetEndPos()- iChunkList[i]->GetStartPos() + 1);                    

            }

       }

    MSRPLOG( "CMSRPMessageHandler::UpdateResponseState exit" )

    }

void CMSRPMessageHandler::ReceiveFileStateL( TInt aBytesTransferred )

    {

    MSRPLOG( "CMSRPMessageHandler::ReceiveFileState enter" )

    MSRPLOG2( "CMSRPMessageHandler::ReceiveFileState Notify %d", iProgress )

    MSRPLOG2( "CMSRPMessageHandler::ReceiveFileState iFileNotified %d", iNotifiedBytes )    

    MSRPLOG2( "CMSRPMessageHandler::ReceiveFileState iunnotified %d", iPendingBytes )

    MSRPLOG2( "CMSRPMessageHandler::ReceiveFileState aBytesTransferred %d", aBytesTransferred )

    MSRPLOG2( "CMSRPMessageHandler::ReceiveFileState iFileSize %d", iFileSize )

    iPendingBytes += aBytesTransferred;

    if(iNotifiedBytes + iPendingBytes == iFileSize)

        {

        iFileTransferComplete = ETrue;

        }

    if(iPendingBytes >= KMaxChunkReadSize)

        {

        MSRPLOG( "CMSRPMessageHandler::ReceiveFileState unnotified exceeds threshold" )

        MSRPLOG2( "CMSRPMessageHandler::ReceiveFileState iFileReceiveComplete: %d", iFileTransferComplete )                

        iNotifiedBytes += iPendingBytes;

        iPendingBytes = 0;

        //notify client of progress

        if(iProgress && !iFileTransferComplete)

            iMSRPMessageObserver->MessageReceiveProgressL(iNotifiedBytes, iFileSize);

        }

     MSRPLOG( "CMSRPMessageHandler::ReceiveFileState exit" )   

     }

TBool 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 == CMSRPResponse::EAllOk) )

            {

            sendResponse = EFalse;

            }

        CleanupStack::PopAndDestroy(frHeaderValue);

        }

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

        {

        aResponseCode = CMSRPResponse::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;

        aConnection.SendL( *this );

        }

    MSRPLOG( "CMSRPMessageHandler::SendResponseL exit" )

	if( aResponseCode == CMSRPResponse::EAllOk )

        return ETrue;

    else

        return EFalse;

    }

TBool CMSRPMessageHandler::IfResponseReqL()

    {

    TBool responseReq = ETrue;

    if( iMessage->FailureReportHeader() )

        {

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

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

            {

             responseReq = EFalse;

            }

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

            {

            responseReq = EFalse;

            }

        CleanupStack::PopAndDestroy(frHeaderValue);     

        }

    return responseReq;

    }

TDesC8& CMSRPMessageHandler::TransactionId( )

    {

    MSRPLOG( "CMSRPMessageHandler::TransactionId enter" )

    return iTransactionId;

    }

CMSRPResponse* CMSRPMessageHandler::GetIncomingResponse( )

    {

    MSRPLOG( "CMSRPMessageHandler::GetIncomingResponse enter" )

    if( iResponse )

        {

        return iResponse;

        }

    return NULL;

    }

void CMSRPMessageHandler::SendMessageL( MMSRPConnection& aConnection )

    {

    MSRPLOG( "CMSRPMessageHandler::SendMessageL enter" )    

    iActiveMsgType = EMSRPMessage;

    aConnection.SendL( *this );

    MSRPLOG( "CMSRPMessageHandler::SendMessageL exit" )

    }

void CMSRPMessageHandler::SendFileL(MMSRPConnection& aConnection)

    {

    MSRPLOG( "CMSRPMessageHandler::SendFileL enter" ) 

    /* Flags  */

    isFile = ETrue;    

    iProgress = iMessage->GetNotifyProgress();

    User::LeaveIfError(iFs.Connect());

    User::LeaveIfError(iFile.Open(iFs, iMessage->GetFileName(), EFileShareReadersOrWriters)); 

    iFile.Size(iFileSize);

    iFileBuffer = HBufC8::NewL(KMaxChunkReadSize);            

    FillFileBufferL();

    iActiveMsgType = EMSRPMessage;

    aConnection.SendL( *this );

    MSRPLOG( "CMSRPMessageHandler::SendFileL exit" )     

    }