/*

* Copyright (c) 2006-2006 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 "SenSoapEnvelope.h"

#include "wsstarmessagecontext.h"

#include "wsstarsessioncontext.h"

#include "SenXmlReader.h"

#include "senlogger.h"

CWSStarMessageContext* CWSStarMessageContext::NewL(SenContext::TContextDirection aDirection, CSenXmlReader*& aParser)

    {

    CWSStarMessageContext* self = NewLC(aDirection, aParser);

    CleanupStack::Pop(self);

    return self;

    }

CWSStarMessageContext* CWSStarMessageContext::NewLC(SenContext::TContextDirection aDirection, CSenXmlReader*& aParser)

    {

    CWSStarMessageContext* self = new (ELeave) CWSStarMessageContext(aDirection, aParser);

    CleanupStack::PushL (self);

    self->ConstructL();

    return self;

    }

CWSStarMessageContext* CWSStarMessageContext::NewLC(

        SenContext::TContextDirection aDirection, CSenXmlReader*& aParser,

        CWSStarSessionContext& aSessionContext)

    {

    CWSStarMessageContext* self =

            new (ELeave) CWSStarMessageContext(aDirection, aParser);

    CleanupStack::PushL (self);

    self->ConstructL(aSessionContext);

    return self;

    }

// Constructor

CWSStarMessageContext::CWSStarMessageContext(SenContext::TContextDirection aDirection, CSenXmlReader*& aParser)

    :iDirection(aDirection),

    iOwnedEnvelope(EFalse),

    iParser(aParser),

    iDescs(EFalse, ETrue),

    iInts(EFalse, ETrue)

    {

    }

// Constructor

void CWSStarMessageContext::ConstructL()

    {

    }

void CWSStarMessageContext::ConstructL(CWSStarSessionContext& aSessionContext)

    {

    UpdateFromSessionContextL(aSessionContext);

    }

// Destructor

CWSStarMessageContext::~CWSStarMessageContext()

    {

    if (iOwnedEnvelope)

        {

        delete iCurrentEnvelope;

        }

    iDescs.Reset();

    iInts.Reset();

    }

//from SessionContext 

CSenSoapMessage* CWSStarMessageContext::GetCurrentSoapMessage()

    {

    if (iCurrentEnvelope)

        {

        return (CSenSoapMessage*)iCurrentEnvelope;

        }

    else

        {

        return NULL;

        }

};

TPtrC8 CWSStarMessageContext::GetMessageL()

    {

    return iCurrentEnvelopeTxt;

    };

void CWSStarMessageContext::UpdateDesC8L(CWSStarSessionContext& aSessionContext, const TDesC8& aKey)

    {

    const TDesC8* ptr =

            aSessionContext.GetDesC8L(aKey);

    if (ptr && !GetDesC8L(aKey))

        {

        User::LeaveIfError(Update(aKey, *ptr));

        }

    }

void CWSStarMessageContext::UpdateIntL(CWSStarSessionContext& aSessionContext, const TDesC8& aKey)

    {

    const TInt* ptr =

            aSessionContext.GetIntL(aKey);

    if (ptr &&!GetIntL(aKey))

        {

        User::LeaveIfError(Update(aKey, *ptr));    

        } 

    }

void CWSStarMessageContext::UpdateFromSessionContextL( CWSStarSessionContext& aSessionContext )

    {

    //becouse of resending we need keep veen message specific stuff inside session ctx

    // (see ASYNC handkleerror)

    if (Direction() == SenContext::EOutgoing)

        {

        const TDesC8* ptr =

        aSessionContext.GetDesC8L( WSStarContextKeys::KTo );

        if ( ptr )

            {

            TInt error = Remove( WSStarContextKeys::KTo );

            if( error )

                {

                TLSLOG_L( KSenCoreServiceManagerLogChannelBase, KMinLogLevel, "CWSStarMessageContext::UpdateFromSessionContextL( CWSStarSessionContext& aSessionContext ):" );

                TLSLOG_FORMAT(( KSenCoreServiceManagerLogChannelBase, KMinLogLevel, _L8("- Remove( WSStarContextKeys::KTo ) returned an error(!): %d => going to 'throw a LEAVE'"), error ));

                User::LeaveIfError( error );

                }

            }        

        UpdateDesC8L(aSessionContext, WSStarContextKeys::KTo);

        UpdateDesC8L(aSessionContext, WSStarContextKeys::KAction);

        UpdateDesC8L(aSessionContext, WSStarContextKeys::KAddressingVersion);

        UpdateDesC8L(aSessionContext, WSStarContextKeys::KTimestampExpires);

        UpdateDesC8L(aSessionContext, WSStarContextKeys::KTimestampCreated);

        UpdateDesC8L(aSessionContext, WSStarContextKeys::KPhoneTimeWhenMTResolved);

        UpdateDesC8L(aSessionContext, WSStarContextKeys::KPOPBase64);

        UpdateDesC8L(aSessionContext, WSStarContextKeys::KBinaryType);

        UpdateIntL(aSessionContext, WSStarContextKeys::KSoapVersion);

        UpdateIntL(aSessionContext, WSStarContextKeys::KPassportEnabled);

        UpdateIntL(aSessionContext, WSStarContextKeys::KMTIsReplacedBySCT);

        UpdateDesC8L(aSessionContext, WSStarContextKeys::KSecurityToken);

        UpdateDesC8L(aSessionContext, WSStarContextKeys::KBody);

        iBody = aSessionContext.GetSenElementL(WSStarContextKeys::KBodyElement);

        UpdateDesC8L(aSessionContext, WSStarContextKeys::KSTR);

        ipSignedParts = (RPointerArray<HBufC8>*)aSessionContext.GetAnyL( WSStarContextKeys::KSignedPartsArray );

#ifdef _SENDEBUG                

        if( !ipSignedParts ) // ipSignedParts == NULL!

            {

            TLSLOG_L( KSenCoreServiceManagerLogChannelBase, KMinLogLevel, "CWSStarMessageContext::UpdateFromSessionContextL( CWSStarSessionContext& aSessionContext ):" );

            TLSLOG_L( KSenCoreServiceManagerLogChannelBase, KMinLogLevel, "- aSessionContext.GetAnyL( WSStarContextKeys::KSignedPartsArray ) returned NULL(!)" );

            }

#endif // _SENDEBUG            

        UpdateIntL(aSessionContext, WSStarContextKeys::KAppInfoPresent);

        UpdateDesC8L(aSessionContext, WSStarContextKeys::KApplicationName);

        UpdateDesC8L(aSessionContext, WSStarContextKeys::KApplicationVendor);

        UpdateDesC8L(aSessionContext, WSStarContextKeys::KApplicationVersion);

        UpdateDesC8L(aSessionContext, WSStarContextKeys::KLocale);

        UpdateDesC8L(aSessionContext, WSStarContextKeys::KManufacturer);

        UpdateDesC8L(aSessionContext, WSStarContextKeys::KModel);

        UpdateDesC8L(aSessionContext, WSStarContextKeys::KDeviceName);

        UpdateDesC8L(aSessionContext, WSStarContextKeys::KDeviceVersion);

        UpdateDesC8L(aSessionContext, WSStarContextKeys::KIMSI);

        }

    else

        {

        UpdateIntL(aSessionContext, WSStarContextKeys::KPassportEnabled);

        }

    }

TInt CWSStarMessageContext::Add(const TDesC8& aKey, CSenSoapEnvelope* aValue)

    {

    TInt results = KErrNone;

    if (aKey == SenContext::KSenCurrentSoapMessageCtxKey())

        {

        if (!iCurrentEnvelope)

            {

            iCurrentEnvelope = aValue;

            }

        else

            {

            results = KErrAlreadyExists;

            }

        }

    return results;

    };

TInt CWSStarMessageContext::Update(const TDesC8& aKey, CSenSoapEnvelope* aValue)

    {

    if (aKey == SenContext::KSenCurrentSoapMessageCtxKey())

        {

        if (iOwnedEnvelope)

            {

            delete iCurrentEnvelope;

            }

        iCurrentEnvelope = aValue;

        }

    return KErrNone;

    };

const CSenSoapEnvelope* CWSStarMessageContext::GetSenSoapEnvelopeL(const TDesC8& aKey)

    {

    if (aKey == SenContext::KSenCurrentSoapMessageCtxKey)

        {

        return iCurrentEnvelope;

        }

    else

        {

        return NULL;

        }

    };

//from MContext       

SenContext::TContextType CWSStarMessageContext::Type() const

    {

    return SenContext::EMessageContext;

    }

SenContext::TContextDirection CWSStarMessageContext::Direction() const

    {

    return iDirection;

    }

//-----------------descs        

TInt CWSStarMessageContext::Add(const TDesC8& aKey, const TDesC8& aValue)

    {

    if (aKey == SenContext::KSenCurrentSoapMessageCtxKey())

        {

        if (! iCurrentEnvelopeTxt.Length())

            {

            iCurrentEnvelopeTxt.Set(aValue);

            return KErrNone;

            }

        else

            {

            return KErrAlreadyExists;

            }

        }

        //version without copy

        //return iDescs.Append(&aKey,&aValue);

        //version with making of copy

        if (!aValue.Length()) return KErrUnderflow;

        HBufC8* newValue = NULL;

        TInt error(KErrNone);

        TRAP(error, newValue = aValue.AllocL());

        if (!error)

            {

            error = iDescs.Append(&aKey,newValue);

            }            

        return error;

    }

//it add(if not exist) or update. So , it is like Set

TInt CWSStarMessageContext::Update(const TDesC8& aKey, const TDesC8& aValue)

    {

    if (aKey == SenContext::KSenCurrentSoapMessageCtxKey())

        {

        iCurrentEnvelopeTxt.Set(aValue);

        return KErrNone;

        }

    //version with makeing of copy

    TInt error(KErrNone);

    if (!aValue.Length()) 

        {

        error = Remove(aKey);

        if (error == KErrNotFound)

                return KErrNone;

            else

                return error;

        }

    HBufC8* newValue = NULL;

    TRAP(error, newValue = aValue.AllocL());

    if (!error)

        {

        error = iDescs.UpdateValue(&aKey,newValue);

        }

    return error;

    }

const TDesC8* CWSStarMessageContext::GetDesC8L(const TDesC8& aKey)

    {

    if (aKey == SenContext::KSenCurrentSoapMessageCtxKey())

        {

        return NULL;

        }

    TInt index = iDescs.Find(aKey);

    if (index != KErrNotFound)

        {

        return iDescs.ValueAt(index);

        }

    else

        {

        return NULL;

        }

    }

TInt CWSStarMessageContext::Remove(const TDesC8& aKey)

    {

    if (aKey == WSStarContextKeys::KBodyElement)

        {

        iBody = NULL;

        return KErrNone;

        }

    else

        {

        return iDescs.RemoveByKey(aKey);

        }

    }

//-------------Ints

TInt CWSStarMessageContext::Add(const TDesC8& aKey, TInt aValue)

    {

    TInt* a = NULL;

    a = new TInt(aValue);

    if (a)

        {

        return iInts.Append(&aKey, a);

        }

    else

        {

        return KErrNoMemory;

        }

    }

TInt CWSStarMessageContext::Update(const TDesC8& aKey, TInt aValue)

    {

    TInt* a = NULL;

    a = new TInt(aValue);

    if (a)

        {

        return iInts.UpdateValue(&aKey, a);

        }

    else

        {

        return KErrNoMemory;

        }

    }

const TInt* CWSStarMessageContext::GetIntL(const TDesC8& aKey)

    {

    TInt index = iInts.Find(aKey);

    if (index!=KErrNotFound)

        {

        return iInts.ValueAt(index);

        }

    else

        {

        return NULL;

        };        

    }

//-----------------elements

TInt CWSStarMessageContext::Add(const TDesC8& aKey, CSenElement* aValue)

    {

    return Update(aKey,aValue);

    }

TInt CWSStarMessageContext::Update(const TDesC8& aKey, CSenElement* aValue)

    {

    if (aKey == WSStarContextKeys::KBodyElement)

        {

        iBody = aValue;

        return KErrNone;

        }

    return KErrNotFound;

    }

const CSenElement* CWSStarMessageContext::GetSenElementL(const TDesC8& aKey)

    {

    if (aKey == WSStarContextKeys::KBodyElement)

        {

        return iBody;

        }

    return NULL;

    }

//-----------------TAnys

TInt CWSStarMessageContext::Add(const TDesC8& /*aKey*/, TAny* /*aValue*/)

    {

    return KErrNotSupported;

    }

TInt CWSStarMessageContext::Update(const TDesC8& /*aKey*/, TAny* /*aValue*/)

    {

    return KErrNotSupported;

    }

TAny* CWSStarMessageContext::GetAnyL(const TDesC8& aKey)	//codescannerwarnings

    {

    if(aKey == WSStarContextKeys::KSignedPartsArray)

        {

        return ipSignedParts;

        }

     else

        {

        return NULL;

        }

    }

const CSenXmlReader* CWSStarMessageContext::GetParser()

    {

    return iParser;

    }

TInt CWSStarMessageContext::Count() const

    {

    return KErrNotSupported;

    }

TPtrC8 CWSStarMessageContext::KeyAtL(TInt /*aIndex*/)

    {

    return KNullDesC8();

    }

void CWSStarMessageContext::Reset() 

    {

    }

MSenMessage* CWSStarMessageContext::MessageL()	//codescannerwarnigs

    {

    return NULL;

    }

TInt CWSStarMessageContext::SetMessage(MSenMessage* /* apMessage */, TBool /* aOwned */)

    {

    return KErrNotSupported;

    }

TInt CWSStarMessageContext::SetProperties(MSenProperties* /* apTransportProperties */, TBool /* aOwned */)

    {

    return KErrNotSupported;

    }

MSenProperties* CWSStarMessageContext::Properties()

    {

    return NULL;    

    }

TInt CWSStarMessageContext::Add(const TDesC8& /* aKey */, MSenMessage* /* apMessage */, TBool /* aOwned */)

    {

    return KErrNotSupported;

    }

TInt CWSStarMessageContext::Update(const TDesC8& /* aKey */, MSenMessage* /* apMessage */, TBool /* aOwned */)

    {

    return KErrNotSupported;

    }

MSenMessage* CWSStarMessageContext::GetMessageL(const TDesC8& /* aKey */)	// codescannerwarnings

    {

    return NULL;

    }

CSenChunk* CWSStarMessageContext::ChunkL()	//codescannerwarnings

    {

    return NULL;

    }

TInt CWSStarMessageContext::SetChunk(CSenChunk* /* apMsgAsChunk */, TBool /* aOwned */)

    {

    return KErrNotSupported;

    }

TInt CWSStarMessageContext::SetDirection( SenContext::TContextDirection /* aDirection */ ) 

    {

    return KErrNotSupported; 

    }

// END OF FILE