/*

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

#include "wsstarmessageutils.h"

#include "SenXmlUtils.h"

#include "sensaxutils.h"

#include "senlogger.h" // private Utils\inc

using namespace WSStarAddressing;

using namespace WSStarAddressingFault;

// Create instance of concrete ECOM interface implementation

CWSStarAddressingHandler* CWSStarAddressingHandler::NewL(TAny* aHandlerCtx)

    {

    MSenHandlerContext* ctx =

        reinterpret_cast<MSenHandlerContext*>( aHandlerCtx);

    CWSStarAddressingHandler* self = new (ELeave) CWSStarAddressingHandler(*ctx);

    CleanupStack::PushL (self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

TInt CWSStarAddressingHandler::InvokeL(MSenMessageContext& aCtx)

    {

    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSStarAddressingHandler::InvokeL(MSenMessageContext& aCtx)")));

    CSenSoapEnvelope* message = 

        const_cast<CSenSoapEnvelope*>(aCtx.GetSenSoapEnvelopeL(

                                    SenContext::KSenCurrentSoapMessageCtxKey)

                                    );

    TPtrC8 txtMessage = aCtx.GetMessageL();

    InitVersionL(aCtx.GetDesC8L(WSStarContextKeys::KAddressingVersion));

    if (message)

        {

        const CSenNamespace* nmSpace = message->Namespace(KAddressingPrefix);

        if (nmSpace)

            {

            InitVersionL(&nmSpace->URI());

            }

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

            {

            return HandleOutboundL(aCtx, message);

            }

        else if (aCtx.Direction()==SenContext::EIncoming)

            {

            return HandleInboundL(aCtx, message);

            }

        else

            {

            TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSStarAddressingHandler::InvokeL(MSenMessageContext& aCtx) - \

                                strange direction")));

            return KErrNotFound;

            }

        }

    else if (txtMessage.Length())

        {

//---------------idea based on method

/*    

TInt CSenWebServiceSession::HandleBodyWithoutParsingL(CSenSoapMessage& aMessage,

                                                      const TDesC8& aResponse)

*/

        TInt ret(KErrNone);

        TInt endTagStart;

        TInt endTagEnd;

        TInt startTagStart;

        TInt startTagEnd;

        TPtrC8 prefix;

        ret = SenSaxUtils::SearchEndTagL(txtMessage,KSenSoapEnvelopeBodyName,

                                         endTagStart, endTagEnd, prefix);

        if ( ret != KErrNotFound )

            {

            ret = SenSaxUtils::SearchStartTagL(txtMessage,prefix,KSenSoapEnvelopeBodyName,

                                               startTagStart, startTagEnd);

            if ( ret != KErrNotFound )

                {

                TPtrC8 startPart(txtMessage.Ptr(),startTagEnd+1);

                TPtrC8 endPart(txtMessage.Ptr()+endTagStart,txtMessage.Size()-endTagStart);

                HBufC8* pXmlWithoutBody = HBufC8::NewLC(startPart.Length()+endPart.Length());

                pXmlWithoutBody->Des().Append(startPart);

                pXmlWithoutBody->Des().Append(endPart);

                CWSStarAddressingHeaderInbound* inbound =

                        CWSStarAddressingHeaderInbound::NewLC(iVersion);

                inbound->SetMessageContext(aCtx);

                CSenXmlReader& reader = const_cast<CSenXmlReader&>(*aCtx.GetParser());

                inbound->SetReader(reader);

                inbound->BuildFrom(*pXmlWithoutBody);

                CleanupStack::PopAndDestroy(inbound);

                CleanupStack::PopAndDestroy(pXmlWithoutBody);

                }

            }

        else//case with empty body - <S:Body/>, so we can parse all

            {

             CWSStarAddressingHeaderInbound* inbound =

                    CWSStarAddressingHeaderInbound::NewLC(iVersion);

            inbound->SetMessageContext(aCtx);

            CSenXmlReader& reader = const_cast<CSenXmlReader&>(*aCtx.GetParser());

            inbound->SetReader(reader);

            inbound->BuildFrom(txtMessage);

            CleanupStack::PopAndDestroy(inbound);

            }

        return ret;

        }

    else

        {

        TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSStarAddressingHandler::InvokeL(MSenMessageContext& aCtx) - \

                            Soap message in message context not exists")));

        return KErrNotFound;

        }

    }    

TInt CWSStarAddressingHandler::HandleInboundL(MSenMessageContext& aCtx, CSenSoapEnvelope* aMessage)

    {

/*

    CWSStarAddressingHeaderInbound* inbound =  CWSStarAddressingHeaderInbound::NewLC(iVersion);

    inbound->SetMessageContext(aCtx);

    CSenXmlReader& reader = const_cast<CSenXmlReader&>(*aCtx.GetParser());

    inbound->SetReader(reader);

    HBufC8* buf = aMessage->AsXmlL();

    CleanupStack::PushL(buf);

    inbound->BuildFrom(*buf);

*/

    CSenElement& header = aMessage->HeaderL();

    CSenElement* elem = NULL;

    CSenElement* addressElem = NULL;    

    elem = CWSStarMessageUtils::FindElementL(KToName, header);

    if (elem)

        {

        const TDesC8& nsUri = elem->NamespaceURI();

        if (!iVersion && (nsUri == KAddressingXmlns200408 ||

            nsUri == KAddressingXmlns200403 ||

            nsUri == KAddressingXmlns200412 ||

            nsUri == KAddressingXmlns200502 ||

            nsUri == KAddressingXmlns200503 ||

            nsUri == KAddressingXmlns200508))

            {

            iVersion = nsUri.AllocL();

            }

        ((MSenContext&)aCtx).Update(WSStarContextKeys::KTo, elem->Content());

        }

    elem = CWSStarMessageUtils::FindElementL(KRelatesToName, header);

    if (elem)

        {

        ((MSenContext&)aCtx).Update(WSStarContextKeys::KRelatesTo, elem->Content());

        }

    elem = CWSStarMessageUtils::FindElementL(KMessageIDName, header);

    if (elem)

        {

        ((MSenContext&)aCtx).Update(WSStarContextKeys::KMessageID, elem->Content());

        }

    elem = CWSStarMessageUtils::FindElementL(KActionName, header);

    if (elem)

        {

        ((MSenContext&)aCtx).Update(WSStarContextKeys::KAction, elem->Content());

        }

    elem = CWSStarMessageUtils::FindElementL(WSStarAddressingEPR::KDeviceAddressName, header);

    if (elem)

        {

        ((MSenContext&)aCtx).Update(WSStarContextKeys::KReplyToDeviceAddress, elem->Content());

        }

    elem = CWSStarMessageUtils::FindElementL(KReplyToName, header);

    if (elem)

        {

        addressElem = CWSStarMessageUtils::FindElementL(KAddressName, *elem);

        if (addressElem)

            {

            ((MSenContext&)aCtx).Update(WSStarContextKeys::KReplyTo, addressElem->Content());

            }

        }

    elem = CWSStarMessageUtils::FindElementL(KFaultToName, header);

    if (elem)

        {

        addressElem = CWSStarMessageUtils::FindElementL(KAddressName, *elem);

        if (addressElem)

            {

            ((MSenContext&)aCtx).Update(WSStarContextKeys::KFaultTo, addressElem->Content());

            }

        }

    elem = CWSStarMessageUtils::FindElementL(KFromName, header);

    if (elem)

        {

        addressElem = CWSStarMessageUtils::FindElementL(KAddressName, *elem);

        if (addressElem)

            {

            ((MSenContext&)aCtx).Update(WSStarContextKeys::KFrom, addressElem->Content());

            }

        }

    _LIT8(Kpp, "pp");

    _LIT8(KCredProperties, "credProperties");

    _LIT8(KCredProperty, "credProperty");

    //_LIT8(KName, "Name");

    CWSStarMessageUtils::RArraySenElements credPropertiesElements;

    CSenElement* ppElem = CWSStarMessageUtils::FindElementL(Kpp, header);

    if(ppElem)

        {

        if(credPropertiesElem)

            {

            CWSStarMessageUtils::FindElementL(KCredProperty, *credPropertiesElem, credPropertiesElements);

            TInt count = credPropertiesElements.Count();

            for(TInt i=0; i<count; i++)

                {

                elem = credPropertiesElements[i];

                const TDesC8* ptr = elem->AttrValue(WSStarContextKeys::KName);

                if ( *ptr == WSStarContextKeys::KMainBrandID )

                    {

                    ((MSenContext&)aCtx).Update(WSStarContextKeys::KMainBrandID, elem->Content());

                    }

                if (*ptr == WSStarContextKeys::KBrandIDList)

                    {

                    ((MSenContext&)aCtx).Update(WSStarContextKeys::KBrandIDList, elem->Content());

                    }            

                }

            }        

        }

/*

    if (!iVersion && inbound->Version())

        {

        iVersion = inbound->Version()->AllocL();

        }

*/    

    if (!aCtx.GetDesC8L(WSStarContextKeys::KRelatesTo))

        {

        TLSLOG_FORMAT((KSenFaultsLogChannel, KSenFaultsLogLevel, 

                        WSStarAddressingFault::KInvalidHeaderFormatString8,

                        &KRelatesToQName(),&WSStarAddressingFault::KMissingTag()));   

        }

    if (!aCtx.GetDesC8L(WSStarContextKeys::KTo))

        {

        TLSLOG_FORMAT((KSenFaultsLogChannel, KSenFaultsLogLevel, KRequiredHeaderFormatString8,

                        &KToQName()));   

        }

    if (!aCtx.GetDesC8L(WSStarContextKeys::KAction))

        {

        TLSLOG_FORMAT((KSenFaultsLogChannel, KSenFaultsLogLevel, KRequiredHeaderFormatString8,

                        &KActionQName()));   

        }

    if (aCtx.GetDesC8L(WSStarContextKeys::KReplyTo) || aCtx.GetDesC8L(WSStarContextKeys::KFaultTo))

        {

        if (!aCtx.GetDesC8L(WSStarContextKeys::KMessageID))

            {

            TLSLOG_FORMAT((KSenFaultsLogChannel, KSenFaultsLogLevel, KRequiredHeaderFormatString8,

                            &KMessageIDQName()));   

            }

        }

    //    CleanupStack::PopAndDestroy(buf);

//    CleanupStack::PopAndDestroy(inbound);

    //CSenElement& body = aMessage->BodyL();

    ShareMyLiterals(aCtx);

    if (aMessage->IsFault())

        {

        TPtrC8 errorCode(KNullDesC8);

        CSenSoapFault* faultElement = aMessage->FaultL();

        if (faultElement)

            {

            TPtrC8 code;

            if (aMessage->NsUri() == KSenSoapEnvelopeXmlns)

                {

                TPtrC8 code = faultElement->FaultCode();                            

                const CSenNamespace* nmSpace = faultElement->Namespace(SenXmlUtils::NsPrefix(code),

                                                                       ETrue);

                code.Set(SenXmlUtils::LocalName(code));

                if (nmSpace)

                    {

                    if (!iVersion)

                        {

                        InitVersionL(&nmSpace->URI());

                        }

                    if (iVersion && 

                        nmSpace->URI() == *iVersion)

                        {

                        errorCode.Set(code);

                        }    

                    }

                }

            else if (aMessage->NsUri() == KSenSoap12EnvelopeXmlns)

                {

                code.Set(faultElement->FaultCode());

                const CSenNamespace* nmSpaceCode = 

                        faultElement->Namespace(SenXmlUtils::NsPrefix(code), ETrue);

                code.Set(SenXmlUtils::LocalName(code));

                if ((nmSpaceCode && 

                    nmSpaceCode->URI() == KSenSoap12EnvelopeXmlns) &&

                    (code == KSender || code == KReceiver))

                    {

                    TPtrC8 subcode = faultElement->FaultSubcode();

                    const CSenNamespace* nmSpace = 

                        faultElement->Namespace(SenXmlUtils::NsPrefix(subcode), ETrue);

                    subcode.Set(SenXmlUtils::LocalName(subcode));

                if (nmSpace)

                    {

                    if (!iVersion)

                        {

                        InitVersionL(&nmSpace->URI());

                        }

                    if (iVersion && 

                        nmSpace->URI() == *iVersion)

                        {

                        errorCode.Set(subcode);

                        }    

                    }

                    }

                }

            if (errorCode.Length()>0)

                {

                if (errorCode == WSStarAddressingFault::KInvalidHeader ||

                    errorCode == WSStarAddressingFault::KRequiredHeader ||

                    errorCode == WSStarAddressingFault::KDestinationUnreachable ||

                    errorCode == WSStarAddressingFault::KActionNotSupported )

                    {

                    ((MSenContext&)aCtx).Update(WSStarSession::KErrorLayer,

                                                WSStarSession::EAddressing);

                    }

                if ((errorCode == WSStarAddressingFault::KEndpointUnavailable)

                    && (code == KReceiver))

                    {

                    ((MSenContext&)aCtx).Update(WSStarSession::KErrorLayer,

                                                WSStarSession::EAddressing);

                    CSenElement* detailElement = faultElement->Element(KFault12DetailLocalname);

                    if (detailElement)

                        {

                        CSenElement* retryElement = detailElement->Element(*iVersion,

                                                                           KRetryAfterName); 

                        if (retryElement)

                            {

                            TPtrC8 retryAfter = retryElement->Content();

                            TLex8 num;

                            TInt retryInt;

                            num.Assign(retryAfter);

                            TInt ret = num.Val(retryInt);

                            if (ret == KErrNone)

                                ((MSenContext&)aCtx).Update(WSStarContextKeys::KRetryAfter,

                                                            retryInt);

                            }

                        }

                    }

                }

            }

        else

            {

            TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSStarAddressingHandler::InvokeL(MSenMessageContext& aCtx) - \

                            Fault element not exists")));

            return KErrNotFound;

            }

        }

    return KErrNone;

    }

TInt CWSStarAddressingHandler::HandleOutboundL(MSenMessageContext& aCtx, 

                                                CSenSoapEnvelope* aMessage)

    {

    if (!iVersion)

        {

        iVersion = KAddressingXmlns200508().AllocL();

        }

    TPtrC8 anonymous(KNullDesC8);

    if (!iVersion->Compare(KAddressingXmlns200403()))

        {

        anonymous.Set(KReplyToAnonymous200403());

        }

     else if(!iVersion->Compare(KAddressingXmlns200408()))

        {

        anonymous.Set(KReplyToAnonymous200408());

        }

     else if(!iVersion->Compare(KAddressingXmlns200412()))

        {

        anonymous.Set(KReplyToAnonymous200412());

        }

     else if(!iVersion->Compare(KAddressingXmlns200502()))

        {

        anonymous.Set(KReplyToAnonymous200502());

        }

     else if(!iVersion->Compare(KAddressingXmlns200503()))

        {

        anonymous.Set(KReplyToAnonymous200503());

        }

     else if(!iVersion->Compare(KAddressingXmlns200508()))

        {

        anonymous.Set(KReplyToAnonymous200508());

        }

    CSenElement& element = aMessage->AsElement();

    element.AddNamespaceL(KAddressingPrefix, *iVersion);

    ((MSenContext&)aCtx).Update(WSStarContextKeys::KAddressingNsHolder, *iVersion);

///////////////    

    const TDesC8* value = NULL;

    const TInt* isPassportEnabled = aCtx.GetIntL(WSStarContextKeys::KPassportEnabled);

    value = aCtx.GetDesC8L(WSStarContextKeys::KMessageID);

    if (!value)

        {

        SetMessageIDL(aCtx);

        }

    if (!isPassportEnabled || (isPassportEnabled && *isPassportEnabled == FALSE))

        {

        CSenElement& header = aMessage->HeaderL();

        value = aCtx.GetDesC8L(WSStarContextKeys::KMessageID);

        if (value)

            {

            CreateElementAddressingL(header, KMessageIDName, *value, EFalse);

            }

        else

            {

            TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSStarAddressingHandler::InvokeL(MSenMessageContext& aCtx) - \

                            MessageId in message context not exists")));

            return KErrNotFound;

            }

        value = aCtx.GetDesC8L(WSStarContextKeys::KTo);

        if (value)

            {

            CreateElementAddressingL(header, KToName, *value, EFalse);

            }

        else

            {

            TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSStarAddressingHandler::InvokeL(MSenMessageContext& aCtx) - \

                            Endpoint in message context not exists")));

            return KErrNotFound;

            }

        value = aCtx.GetDesC8L(WSStarContextKeys::KAction);

        if (value)

            {

            CreateElementAddressingL(header, KActionName, *value, EFalse);

            }

        else

            {

            TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSStarAddressingHandler::InvokeL(MSenMessageContext& aCtx) - \

                            Action in message context not exists")));

            return KErrNotFound;

            }

        value = aCtx.GetDesC8L(WSStarContextKeys::KRelatesTo);

        if (value)

            {

            CreateElementAddressingL(header, KRelatesToName, *value, EFalse);

            }

        value = aCtx.GetDesC8L(WSStarContextKeys::KFrom);

        if (value)

            {

            CreateElementAddressingL(header, KFromName, *value, ETrue);

            }

        value = aCtx.GetDesC8L(WSStarContextKeys::KReplyTo);

        if (value)

            {

            CSenElement* element = CreateElementAddressingL(header, KReplyToName, *value, ETrue);

            const TDesC8* mwsNs = NULL;

            mwsNs = aCtx.GetDesC8L(WSStarContextKeys::KMwsNamespace);

            if (mwsNs)

                {

                const TDesC8* deviceId = NULL;

                deviceId = aCtx.GetDesC8L(WSStarContextKeys::KReplyToDeviceAddress);

                if (deviceId && element)

                    {

                    ((CWSStarAddressingEPR*)element)->AddDeviceAddressL(*mwsNs,*deviceId);

                    }

                }

            }

        else

            {

            CSenElement* element = CreateElementAddressingL(header, KReplyToName, 

                                                            anonymous, ETrue);

            ((MSenContext&)aCtx).Update(WSStarContextKeys::KReplyTo, anonymous);

            const TDesC8* mwsNs = NULL;

            mwsNs = aCtx.GetDesC8L(WSStarContextKeys::KMwsNamespace);

            if (mwsNs)

                {

                const TDesC8* deviceId = NULL;

                deviceId = aCtx.GetDesC8L(WSStarContextKeys::KReplyToDeviceAddress);

                if (deviceId && element)

                    {

                    ((CWSStarAddressingEPR*)element)->AddDeviceAddressL(*mwsNs,*deviceId);

                    }

                }

            }

        value = aCtx.GetDesC8L(WSStarContextKeys::KFaultTo);

        if (value)

            {

            CreateElementAddressingL(header, KFaultToName, *value, ETrue);

            }    

        if(aCtx.GetIntL(WSStarContextKeys::KAppInfoPresent))

            {

            AddAppInfoHeaderL(aCtx,header);

            }

        }

    CSenElement& body = aMessage->BodyL();

    CSenElement* addressHolderEl = NULL;

    do

        {

        addressHolderEl = 

            CWSStarMessageUtils::GetMarkedElementL(body,  WSStarContextKeys::KAddressAttrMark);

        if (addressHolderEl)