/*
* Copyright (c) 2002-2005 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:        
*
*/








// INCLUDE FILES
#include <SenXmlUtils.h>
#include <SenServiceConnection.h>


#include "idwsfsessionconsumer.h"
#include "idwsfmessage.h"
#include "sendebug.h"
#include "senlogger.h"

#include <flogger.h>

CIdWsfSessionConsumer* CIdWsfSessionConsumer::NewL(MSenRemoteServiceConsumer& aServiceConsumer,
                                                   RFileLogger& aLogger)
    {
    CIdWsfSessionConsumer* pSelf =
        CIdWsfSessionConsumer::NewLC(aServiceConsumer, aLogger);
    CleanupStack::Pop(pSelf);
    return pSelf;
    }

CIdWsfSessionConsumer* CIdWsfSessionConsumer::NewLC(MSenRemoteServiceConsumer& aServiceConsumer,
                                                    RFileLogger& aLogger)
    {
    CIdWsfSessionConsumer* pSelf =
                        new (ELeave) CIdWsfSessionConsumer(aServiceConsumer, aLogger);
    CleanupStack::PushL(pSelf);
    pSelf->ConstructL();
    return pSelf;
    }

CIdWsfSessionConsumer::~CIdWsfSessionConsumer()
    {
    delete iSentMessageId;
    delete iReceivedMessageId;
    iSentMessages.Reset();
    }

CIdWsfSessionConsumer::CIdWsfSessionConsumer(MSenRemoteServiceConsumer& aServiceConsumer,
                                             RFileLogger& aLogger)
:   iConsumer(aServiceConsumer),
    iLogger(aLogger),
    iSentMessageId(NULL),
    iReceivedMessageId(NULL),
    iSentMessages(ETrue, ETrue)
    {
    }


const TDesC8& CIdWsfSessionConsumer::Id() const
    {
    return iConsumer.Id();
    }

TInt CIdWsfSessionConsumer::SetSessionL(MSenRemoteServiceSession& aServiceSession)
    {
    iConsumer.SetSessionL(aServiceSession);
    return KErrNone;
    }

TInt CIdWsfSessionConsumer::HandleIdWsfMessageL( CIdWsfMessage* apMessage,
                                                 const TInt aTxnId,
                                                 MSenProperties* aResponseTransportProperties,
                                                 TBool aCompleteMessage )
    {
    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"CIdWsfSessionConsumer::HandleIdWsfMessageL");
    
    TInt retVal(KErrNone);
    if ( apMessage )
        {
        CleanupStack::PushL( apMessage ); // ownership is here
    
        iSentMessages.RemoveByKey( apMessage->MessageId() );
    
        HBufC8* pMessageAsString = NULL;
        
    	//TSW ID: EMKY-6S4CGS & ID:EMKY-6N3AGA
    	// Check if aCompleteMessage in ON then get entire envelope or else only body
        if ( aCompleteMessage )
            {
            pMessageAsString = apMessage->AsXmlL();
            }
        else
            {
            pMessageAsString = apMessage->BodyAsStringL();
            }
        CleanupStack::PopAndDestroy( apMessage ); // object serialized to descriptor, de-alloc!
    
        if( pMessageAsString )
            {
            retVal = iConsumer.HandleMessageL(pMessageAsString, aTxnId, aResponseTransportProperties);
            }
        else
            {
            TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"CIdWsfSessionConsumer::HandleIdWsfMessageL:");
            TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"- Fatal(!): pMessageAsString == NULL, calling remote consumer's HandleErrorL with KErrSenNoSoapBody");
            retVal = iConsumer.HandleErrorL(NULL, KErrSenNoSoapBody, aTxnId, aResponseTransportProperties);
            }
        }
    else // apMessage == NULL
        {
        TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"CIdWsfSessionConsumer::HandleIdWsfMessageL:");
        TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"- Fatal(!): apMessage == NULL, calling remote consumer's HandleErrorL with KErrSenInternalError");
        retVal = iConsumer.HandleErrorL( NULL, KErrSenInternal, aTxnId, aResponseTransportProperties);
        TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase   , KMinLogLevel  ,_L("CIdWsfSessionConsumer::HandleIdWsfMessageL - HandleErrorL returned: %d. Returning KErrSenInternalError in ANY case."), retVal));
        retVal = KErrSenInternal;            
        }        
    return retVal;
    }

TInt CIdWsfSessionConsumer::HandleMessageL( HBufC8* apMessage,
                                            const TInt aTxnId,
                                            MSenProperties* aResponseTransportProperties ) 
    {
    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"CIdWsfSessionConsumer::HandleMessageL - passing message to consumer");
    return iConsumer.HandleMessageL( apMessage, aTxnId, aResponseTransportProperties );
    }

TInt CIdWsfSessionConsumer::HandleErrorL( HBufC8* apError,
                                          const TInt aErrorCode,
                                          const TInt aTxnId,
                                          MSenProperties* aResponseTransportProperties )
    {
    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"CIdWsfSessionConsumer::HandleErrorL - passing error to consumer");
    return iConsumer.HandleErrorL( apError, aErrorCode, aTxnId, aResponseTransportProperties );
    }

void CIdWsfSessionConsumer::SetStatusL(const TInt status)
    {
    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"CIdWsfSessionConsumer::SetStatusL");
    iConsumer.SetStatusL(status);
    }

TInt CIdWsfSessionConsumer::MessageForSendingL( const TDesC8& aBody,
                                                const TDesC8& aReceivedMessageId,
                                                CIdWsfMessage*& apMessage )
    {
    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"CIdWsfSessionConsumer::MessageForSendingL");
    if(aReceivedMessageId.Length()>0)
        {
        apMessage = CIdWsfMessage::NewL(aReceivedMessageId);
        }
    else
        {
        apMessage = CIdWsfMessage::NewL();
        }

    apMessage->SetBodyL(aBody);
    iSentMessages.Append(apMessage->MessageId().AllocL(), aBody.AllocL());
    return KErrNone;
    }

void CIdWsfSessionConsumer::ConstructL()
    {
    }

void CIdWsfSessionConsumer::SetSentMessageIdL(const TDesC8& aSentMessageId)
    {
    HBufC8* pNew = NULL;
    if(aSentMessageId.Length()>0)
    pNew = aSentMessageId.AllocL();    
    delete iSentMessageId;
    iSentMessageId = pNew;
    }

TPtrC8 CIdWsfSessionConsumer::SentMessageId()
    {
    if(iSentMessageId)
        {
        return *iSentMessageId;
        }
    else
        {
        return KNullDesC8();
        }
    }

void CIdWsfSessionConsumer::SetReceivedMessageIdL(
                                            const TDesC8& aReceivedMessageId)
    {
    HBufC8* pNew =NULL;
    if(aReceivedMessageId.Length()>0)
        pNew = aReceivedMessageId.AllocL();
    delete iReceivedMessageId;
    iReceivedMessageId = pNew;
    }

TPtrC8 CIdWsfSessionConsumer::ReceivedMessageId()
    {
    if(iReceivedMessageId)
        return *iReceivedMessageId;
    else
        return KNullDesC8();
    }



TBool CIdWsfSessionConsumer::Expects(const TDesC8& aRefToMessageID)
    {
    TInt index = iSentMessages.Find(aRefToMessageID);
    if (index != KErrNotFound)
        {
        return ETrue;
        }

    return EFalse;
    }

TDesC8* CIdWsfSessionConsumer::BodyL(const TDesC8& aMessageID) const
    {
    HBufC8* pBody = NULL;

    TInt index = iSentMessages.Find(aMessageID);
    if (index != KErrNotFound)
        {
        pBody = (HBufC8*)iSentMessages.ValueAt(index);
        }

    return pBody;
    }

MSenTransport& CIdWsfSessionConsumer::TransportL()
    {
    return iConsumer.TransportL();
    }

CSenIdentifier& CIdWsfSessionConsumer::Identifier() const
    {
    return iConsumer.Identifier();
    }


// enable file logging (macros)
RFileLogger* CIdWsfSessionConsumer::Log() const
    {
    return (RFileLogger*) &iLogger;
    }


TInt CIdWsfSessionConsumer::ChunkByTxnIdL(TInt aTxnId, CSenChunk*& aChunk)
    {
    return iConsumer.ChunkByTxnIdL(aTxnId, aChunk);
    }

void CIdWsfSessionConsumer::FileProgress(TInt /*aTxnId*/, TBool /*aIncoming*/, TBool /*aIsSoap*/,
                const TDesC8& /*aSoapOrCid*/, TInt /*aProgress*/)
    {
    }
void CIdWsfSessionConsumer::SetDataTrafficDetails( TSenDataTrafficDetails& /* aDetails*/)  
	{
	}
// End of file