/*

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

#include <SenHttpTransportProperties.h>

#include "senvtcptransportproperties.h"

#include <SenParser.h>

#include <MSenProperties.h>

#include <MSenMessage.h>

#include "senmessagecontext.h"

#include "SenSoapMessage2.h"

//using namespace SenContext;

EXPORT_C CSenHostletResponse* CSenHostletResponse::NewL(const TInt aRequestId)

    {

    CSenHostletResponse* pNew = CSenHostletResponse::NewLC(aRequestId);

    CleanupStack::Pop();

    return pNew;

    }

EXPORT_C CSenHostletResponse* CSenHostletResponse::NewLC(const TInt aRequestId)

    {

    CSenHostletResponse* pNew = new(ELeave) CSenHostletResponse(aRequestId);

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL();

    return pNew;

    }

void CSenHostletResponse::BaseConstructL()

    {

    }

CSenHostletResponse::CSenHostletResponse(const TInt aRequestId)

: iRequestId(aRequestId),

  iResponseCode(KErrNone),

  ipOwnedResponseUtf8(NULL),

  ipMessageContext(NULL)

    {

    }

EXPORT_C CSenHostletResponse::~CSenHostletResponse()

    {

    delete ipOwnedResponseUtf8;

    ipOwnedResponseUtf8 = NULL;

    delete ipMessageContext;

    ipMessageContext = NULL;

    }

EXPORT_C void CSenHostletResponse::SetResponseUtf8L(const TDesC8& aResponseBodyUtf8,

                                                    const TInt aResponseCode,

                                                    MSenProperties* apResponseProperties,

                                                    MSenMessage* apMessage)

    {

    HBufC8* pTemp = aResponseBodyUtf8.AllocL();

    iResponseCode = aResponseCode;

    delete ipOwnedResponseUtf8;

    ipOwnedResponseUtf8 = NULL;

    ipOwnedResponseUtf8 = pTemp;

    TInt error(KErrNone);

    MSenProperties* p = NULL;

    if( apResponseProperties && apResponseProperties->PropertiesClassType() != MSenProperties::ENotInUse )

        {

        p = apResponseProperties->Clone(error);

        }

    if( p )

        {

        // Create new message context

        delete ipMessageContext;  

        ipMessageContext = NULL;

        MessageContextL( p );

        }

    else

        {

        MessageContextL();

        }

    MSenMessageContext& ctx = MessageContextL();

    MSenMessage* pMessage = NULL;

    if( !apMessage ) 

        {

        pMessage = CSenSoapMessage2::NewL( ctx ); // ctx holds the transport properties, if such exist

        ctx.SetMessage(pMessage, ETrue);

        }

    else

        {

        pMessage = apMessage->CloneL();

        ctx.SetMessage(pMessage, ETrue);

        }        

    // Set the message into context, with possible properties..

    error = 0; // not used in release builds

/*

    MSenProperties* pResponseProperties = NULL;

    if( apResponseProperties && apResponseProperties->PropertiesClassType() != MSenProperties::ENotInUse )

        {

        switch(apResponseProperties->PropertiesClassType())

            {

            case MSenProperties::ENotInUse:

                {

                break;

                }

            case MSenProperties::ESenXmlProperties:

            case MSenProperties::ESenLayeredXmlProperties: // flatten the props

                {

                pResponseProperties = CSenXmlProperties::NewL(); // iSerializedMessage, *pReader);

                break;

                }

            case MSenProperties::ESenTransportProperties:

            case MSenProperties::ESenLayeredTransportProperties: // flatten the props

                {

                pResponseProperties = CSenTransportProperties::NewL();

                break;

                }

            case MSenProperties::ESenHttpTransportProperties:

            case MSenProperties::ESenLayeredHttpTransportProperties: // flatten the props

                {

                pResponseProperties = CSenHttpTransportProperties::NewL();

                break;

                }

            case MSenProperties::ESenVtcpTransportProperties:

            case MSenProperties::ESenLayeredVtcpTransportProperties: // flatten the props

                {

                pResponseProperties = CSenVtcpTransportProperties::NewL();

                break;

                }

            default: 

                {

                break;

                }

            }

        if( ipResponseProperties )  

            {

            HBufC8* pSerializedProperties = apResponseProperties->AsUtf8LC();

            if (pSerializedProperties && pSerializedProperties->Length()>0)

                {

                TRAPD( err, ipResponseProperties->ReadFromL(*pSerializedProperties); ) // suppress any parsing leave

                TInt unused(err);

                err = unused;

                }

            CleanupStack::PopAndDestroy(pSerializedProperties);

            }

        }

*/

    }

EXPORT_C MSenProperties* CSenHostletResponse::ResponseProperties()

    {

    TInt leaveCode(KErrNone);

    MSenMessageContext* pCtx = NULL;

    MSenMessage* pMessage = NULL;

    TRAP( leaveCode, pCtx = &(MessageContextL()); )

    if( !leaveCode && pCtx )

        {

        TRAP( leaveCode, pMessage = pCtx->MessageL(); )

        //pMessage = pCtx->Message();

        if( !leaveCode && pMessage )

            {

            return pMessage->Properties();

            }

        }

    return NULL; // not found

    }

EXPORT_C MSenMessage* CSenHostletResponse::ResponseMessageL()

    {

    TInt leaveCode(KErrNone);

    MSenMessage* pMsg = NULL;

    TRAP( leaveCode,  pMsg = MessageContextL().MessageL(); )

    if( leaveCode == KErrNone )

        {

        return pMsg;

        }

    leaveCode = 0; // ignored

    return NULL;        

    }

EXPORT_C HBufC8* CSenHostletResponse::ExtractResponseUtf8()

    {

    HBufC8* pResult = ipOwnedResponseUtf8;

    ipOwnedResponseUtf8 = NULL;

    return pResult;

    }

EXPORT_C TPtrC8 CSenHostletResponse::ResponseUtf8()

    {

    if(ipOwnedResponseUtf8)

        {

        return *ipOwnedResponseUtf8;

        }

    else

        {

        return KNullDesC8();

        }

    }

EXPORT_C TInt CSenHostletResponse::RequestId() const

    {

    return iRequestId;

    }

EXPORT_C TInt CSenHostletResponse::ResponseCode() const

    {

    return iResponseCode;

    }

MSenMessageContext& CSenHostletResponse::MessageContextL(MSenProperties* apProperties)

    {

    if( !ipMessageContext )

        {

        if( apProperties )

            ipMessageContext = CSenMessageContext::NewL(SenContext::EOutgoing, apProperties);

        else

            {

            CSenXmlProperties* p = CSenXmlProperties::NewL();

            CleanupStack::PushL(p);

            ipMessageContext = CSenMessageContext::NewL(SenContext::EOutgoing, p);

            CleanupStack::Pop(p);

            }

        }

    return *ipMessageContext;

    }

// END OF FILE