/*

* 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 <s32strm.h>

#include <SenXmlUtils.h>

#include <SenDomFragmentBase.h>

#include <xmlengnodelist.h>

#include "SenSoapEnvelope2.h"

#include "SenSoapFault2.h"

#include "senlayeredtransportproperties.h"

#include "senmessagecontext.h"

#include "msenmessagecontext.h"

#include "SenXmlProperties.h" // for de-alloc

#include "senlayeredxmlproperties.h" // for de-alloc

#include "sendebug.h"

#include "senlogger.h"

#include "wslibxml2utils.h"

EXPORT_C CSenSoapEnvelope2* CSenSoapEnvelope2::NewL()

    {

    TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapEnvelope2::NewL()");    

    CSenSoapEnvelope2* pNew = CSenSoapEnvelope2::NewLC();

    CleanupStack::Pop( pNew ); // pNew

    return pNew;    

    }

EXPORT_C CSenSoapEnvelope2* CSenSoapEnvelope2::NewLC()

    {

    TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapEnvelope2::NewLC()");    

    CSenSoapEnvelope2* pNew = new (ELeave) CSenSoapEnvelope2();

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL();

    return pNew;

    }

EXPORT_C CSenSoapEnvelope2* CSenSoapEnvelope2::NewL(MSenMessageContext& aContext)

    {

    TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapEnvelope2::NewL(aContext)");    

    CSenSoapEnvelope2* pNew = CSenSoapEnvelope2::NewLC(aContext);

    CleanupStack::Pop(pNew); // pNew

    return pNew;    

    }

EXPORT_C CSenSoapEnvelope2* CSenSoapEnvelope2::NewLC(MSenMessageContext& aContext)

    {

    TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapEnvelope2::NewLC(aContext)");    

    CSenSoapEnvelope2* pNew = new (ELeave) CSenSoapEnvelope2();

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL(aContext);

    return pNew;

    }

EXPORT_C CSenSoapEnvelope2* CSenSoapEnvelope2::NewL(CSenSoapEnvelope2& aEnvelope)

    {

    TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapEnvelope2::NewLC(aEnvelope)");    

    CSenSoapEnvelope2* pNew = CSenSoapEnvelope2::NewLC(aEnvelope);

    CleanupStack::Pop(pNew); // pNew

    return pNew;    

    }

EXPORT_C CSenSoapEnvelope2* CSenSoapEnvelope2::NewLC(CSenSoapEnvelope2& aEnvelope)

    {

    TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapEnvelope2::NewLC(aEnvelope)");    

    CSenSoapEnvelope2* pNew = new (ELeave) CSenSoapEnvelope2();

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL(aEnvelope);

    return pNew;

    }

EXPORT_C void CSenSoapEnvelope2::BaseConstructL(TSOAPVersion aVersion)

    {

    if (aVersion != ESOAP12)

        {

        CSenFragmentBase::BaseConstructL(KSenSoapEnvelopeXmlns,

                                         KSenSoapEnvelopeName,

                                         KSenSoapEnvelopePrefix);

        }

    else

        {

        CSenFragmentBase::BaseConstructL(KSenSoap12EnvelopeXmlns,

                                         KSenSoapEnvelopeName,

                                         KSenSoapEnvelopePrefix);

        }

    }

EXPORT_C void CSenSoapEnvelope2::BaseConstructL(MSenMessageContext& aContext)

    {

    ipNotOwnedContext = &aContext;

    BaseConstructL(ESOAP11);

    }

EXPORT_C void CSenSoapEnvelope2::BaseConstructL(MSenMessageContext& aContext, TSOAPVersion aVersion)

    {

    ipNotOwnedContext = &aContext;

    BaseConstructL(aVersion);

    }

EXPORT_C void CSenSoapEnvelope2::BaseConstructL()

    {

    BaseConstructL(ESOAP11);

    }

EXPORT_C void CSenSoapEnvelope2::BaseConstructL(CSenSoapEnvelope2& aEnvelope)

    {

    CSenFragmentBase::BaseConstructL(aEnvelope.AsElementL());

    iTransactionId       = aEnvelope.iTransactionId;

    ipNotOwnedContext    = aEnvelope.ipNotOwnedContext;

    iFault               = aEnvelope.iFault;

    iDirection           = aEnvelope.iDirection;

    ipNotOwnedContext    = aEnvelope.ipNotOwnedContext;

    if ( aEnvelope.ipSoapAction )

        {

        ipSoapAction = aEnvelope.ipSoapAction->AllocL();

        }

    if ( aEnvelope.ipBodyFragment )

        {

        TXmlEngElement envelope = AsElementL();

        TXmlEngElement body;

        RXmlEngNodeList<TXmlEngElement> list;

        CleanupClosePushL(list);

        envelope.GetElementsByTagNameL(list, KSenSoapEnvelopeBodyName,

                                             NsUri());

        if ( list.Count() > 0 )

            {

            body = list.Next();

            ipBodyFragment = CSenFragmentBase::NewL(body, AsDocumentL());

            }

        CleanupStack::PopAndDestroy(&list);

        }

    if ( aEnvelope.ipHeaderFragment )

        {

        TXmlEngElement envelope = AsElementL();

        TXmlEngElement header;

        RXmlEngNodeList<TXmlEngElement> list;

        CleanupClosePushL(list);

        envelope.GetElementsByTagNameL(list, KSenSoapEnvelopeHeaderName,

                                             NsUri());

        if ( list.Count() > 0 )

            {

            ipHeaderFragment = CSenFragmentBase::NewL(header, AsDocumentL());

            }

        CleanupStack::PopAndDestroy(&list);

        }

    if ( aEnvelope.ipProperties )

        {

        ipProperties = aEnvelope.ipProperties->CloneL();

        }    

    }

CSenSoapEnvelope2::CSenSoapEnvelope2()

:   ipBodyFragment(NULL),

    ipHeaderFragment(NULL),

    ipSoapAction(NULL),

    {

    }

EXPORT_C CSenSoapEnvelope2::~CSenSoapEnvelope2()

    {

    if(ipBodyFragment)

        {

        ipBodyFragment->ExtractElement();

        delete ipBodyFragment;

        }

    if(ipHeaderFragment)

        {

        ipHeaderFragment->ExtractElement(); // // delegate's element is owned by us

        delete ipHeaderFragment;

        }

    delete ipSoapAction;

    if( ipProperties )

        {

        if ( ipProperties->IsSafeToCast( MSenProperties::ESenXmlProperties ) )

            {

            CSenXmlProperties* pFlatProps = (CSenXmlProperties*)ipProperties;

            delete pFlatProps;

            ipProperties = NULL;

            }

        else if ( ipProperties->IsSafeToCast( MSenProperties::ESenLayeredXmlProperties ) )

            {

            CSenLayeredXmlProperties* pLayeredProps = (CSenLayeredXmlProperties*)ipProperties;

            delete pLayeredProps;

            ipProperties = NULL;

            }

        // else // TLS log as fatal..

        }

    }

EXPORT_C void CSenSoapEnvelope2::OnStartElementL(const RTagInfo& aElement,

    	                                         const RAttributeArray& aAttributes,

                                                 TInt /*aErrorCode*/)

    {

    TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapEnvelope2::OnStartElementL");    

    const TPtrC8 saxLocalName   = aElement.LocalName().DesC();

    const TPtrC8 saxNsUri       = aElement.Uri().DesC();

    const TPtrC8 saxPrefix      = aElement.Prefix().DesC();

    switch (iState)

        {

        case KSenStateIgnore:

            {

            // check if we encounter the start of a soap:Envelope...

            if ( iElement.IsNull() && saxNsUri == NsUri() &&

                 saxLocalName == KSenSoapEnvelopeName )

                {

                if ( saxNsUri == KNullDesC8 && saxPrefix == KNullDesC8 )

                    {

                    iDocument.CreateDocumentElementL(saxLocalName);

                    }

                else

                    {

                    if ( saxPrefix == KNullDesC8 )

                        {

                        iDocument.CreateDocumentElementL(saxLocalName,

                                                         saxNsUri,

                                                         KNullDesC8);

                        }

                    else

                        {

                        iDocument.CreateDocumentElementL(saxLocalName,

                                                         saxNsUri,

                                                         saxPrefix);

                        }

                    }

                iElement = iDocument.DocumentElement();        

                }

            if ( iElement.NotNull() && saxLocalName == KSenSoapEnvelopeName && saxNsUri != NsUri() )

                {

                iElement.Remove();

                if ( saxNsUri == KNullDesC8 && saxPrefix == KNullDesC8 )

                    {

                    iDocument.CreateDocumentElementL(saxLocalName);

                    }

                else

                    {

                    if ( saxPrefix == KNullDesC8 )

                        {

                        iDocument.CreateDocumentElementL(saxLocalName,

                                                         saxNsUri,

                                                         KNullDesC8);

                        }

                    else

                        {

                        iDocument.CreateDocumentElementL(saxLocalName,

                                                         saxNsUri,

                                                         saxPrefix);

                        }

                    }

                iElement = iDocument.DocumentElement();        

                }

            if ( iElement.NotNull() && LocalName() == saxLocalName &&

                 NsUri() == saxNsUri )

                {

                TXmlEngElement element = AsElementL();

                WsXmlUtils domUtils;       

                domUtils.XmlEngRenameElementL(element, saxLocalName, saxNsUri, saxPrefix);

                AddAttributesToElementL(element, aAttributes);

                }

            else if ( saxNsUri == NsUri() )

                {

                // we are interested in SOAP Header

                if ( saxLocalName == KSenSoapEnvelopeHeaderName )

                    {

                    iState = KStateParsingSoapHeader;

                    // Make sure that header element exists:

                    // == this ensures that we add a "Header"

                    // element to the children:

                    TXmlEngElement header = HeaderL();

                    WsXmlUtils domUtils;       

                    domUtils.XmlEngRenameElementL(header, saxLocalName, saxNsUri, saxPrefix);

                    AddAttributesToElementL(header, aAttributes);

                    }

                else if( saxLocalName == KSenSoapEnvelopeBodyName )

                    {

                    iState = KStateParsingSoapBody;

                    TXmlEngElement body = BodyL();

                    WsXmlUtils domUtils;

                    domUtils.XmlEngRenameElementL(body, saxLocalName, saxNsUri, saxPrefix);

                    AddAttributesToElementL(body, aAttributes);

                    }

                //ESLI-6WEN9V

                //This case is to handle fault which lies outside the body or without body

                else if( saxLocalName == KSenSoapFaultName)

	                 	{

	                 	iFault = ETrue;

	                	RSenDocument document = AsDocumentL();

	                	TXmlEngElement element = BodyL();

	                	// delegate parsing to a SOAPFaultFragment to keep

	                	// a structured representation.

	                	ipBodyFragment = CSenSoapFault2::NewL(saxNsUri,

	                                                      saxLocalName,

	                                                      saxPrefix,

	                                                      aAttributes,

	                                                      element,

	                                                      document);

	                	OnDelegateParsingL(*ipBodyFragment);	

	                 	}

                //ESLI-6WEN9V

                }

            break;

            }

        case KStateParsingSoapHeader:

            {

            ParseHeaderL(aElement, aAttributes);

            }

            break;

        case KStateParsingSoapBody:

            {

            if ( ipBodyFragment )

                {

                ipBodyFragment->ExtractElement();

                delete ipBodyFragment;

                ipBodyFragment = NULL;

                }

            // check if we encounter a Fault

            if ( saxLocalName == KSenSoapFaultName )

                {

                iFault = ETrue;

                RSenDocument document = AsDocumentL();

                TXmlEngElement element = BodyL();

                // delegate parsing to a SOAPFaultFragment to keep

                // a structured representation.

                ipBodyFragment = CSenSoapFault2::NewL(saxNsUri,

                                                      saxLocalName,

                                                      saxPrefix,

                                                      aAttributes,

                                                      element,

                                                      document);

                OnDelegateParsingL(*ipBodyFragment);

                }

            else

                {

                RSenDocument document = AsDocumentL();

                TXmlEngElement element = BodyL();

                // Delegate uses same document

                // Parent for delegate will be body

				ipBodyFragment = CreateBodyFragmentL(saxNsUri, 

				                                     saxLocalName,

					                                 saxPrefix, 

					                                 aAttributes,

					                                 element, 

					                                 document);

                OnDelegateParsingL(*ipBodyFragment);

                }

            }

            break;

        default:

            break;

        }

    }

EXPORT_C void CSenSoapEnvelope2::OnEndElementL(

                                            const RTagInfo& aElement,

                                            TInt /*aErrorCode*/)

    {

    TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapEnvelope2::OnEndElementL");    

    const TPtrC8 saxLocalName   = aElement.LocalName().DesC();

    const TPtrC8 saxNsUri       = aElement.Uri().DesC();

    const TPtrC8 saxPrefix      = aElement.Prefix().DesC();

    switch (iState)

        {

        case KSenStateIgnore:

            {

            break;

            }

        case KStateParsingSoapHeader:

            {

            if (saxNsUri == NsUri() && saxLocalName == KSenSoapEnvelopeHeaderName)

                {

                iState = KSenStateIgnore;

                }

            break;

            }

        case KStateParsingSoapBody:

            {

            if (saxNsUri == NsUri() && saxLocalName == KSenSoapEnvelopeBodyName)

                {

                iState = KSenStateIgnore;

                }

/*            else

                {

                if(ipBodyFragment)

                    {

                    //ipBodyFragment->EnsureNamespacesL();

                    }

                }*/

            }

            break;

        default:

            break;

        }

    }

EXPORT_C TXmlEngElement CSenSoapEnvelope2::SetBodyL(TXmlEngElement aBodyElement)

    {

    TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapEnvelope2::SetBodyL(aBodyElement)");    

    if ( aBodyElement.Name() == KSenSoapFaultName &&  aBodyElement.NamespaceUri() == NsUri() )

        {

        iFault = ETrue;

        }

    TXmlEngElement body = BodyL();

    body.RemoveChildren();

    aBodyElement.MoveTo(body);

    return aBodyElement;

    }

EXPORT_C TPtrC8 CSenSoapEnvelope2::SetBodyL(const TDesC8& aBody)

    {

    TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapEnvelope2::SetBodyL(aBody)");

    TLSLOG_ALL(KSenMessagesLogChannel, KMaxLogLevel, aBody);

    TXmlEngElement body = BodyL();

    body.SetTextNoEncL(aBody);

    return TPtrC8(aBody);

    }

EXPORT_C TXmlEngElement CSenSoapEnvelope2::BodyL()

    {

    TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapEnvelope2::BodyL()");

    TXmlEngElement envelope = AsElementL();

    TXmlEngElement body;

    RXmlEngNodeList<TXmlEngElement> list;

    CleanupClosePushL(list);

    envelope.GetElementsByTagNameL(list, KSenSoapEnvelopeBodyName,

                                         NsUri());

    if ( list.Count() > 0 )

        {

        body = list.Next();

        }

    else

        {

        body = envelope.AddNewElementL(KSenSoapEnvelopeBodyName);

        // Check if namespace declaration

        // is already defined in envelope.

        // => Should be!

        TXmlEngNamespace ns = envelope.LookupNamespaceByUriL(NsUri());

        if ( ns.IsUndefined() )

            {

            // Namespace declaration will be added

            body.AddNamespaceDeclarationL(NsUri(), KNullDesC8);

            }

        WsXmlUtils domUtils;       

        domUtils.XmlEngRenameElementL(body, KSenSoapEnvelopeBodyName, NsUri(), KNullDesC8);

        }    

    CleanupStack::PopAndDestroy(&list);

    return body;

    }

EXPORT_C TXmlEngElement CSenSoapEnvelope2::HeaderL()

    {

    TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapEnvelope2::HeaderL()");

    TXmlEngElement envelope = AsElementL();

    TXmlEngElement header;

    RXmlEngNodeList<TXmlEngElement> list;

    CleanupClosePushL(list);

    envelope.GetElementsByTagNameL(list, KSenSoapEnvelopeHeaderName,

                                         NsUri());

    if ( list.Count() > 0 )

        {

        header = list.Next();

        }

    else

        {