/*

* 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 FILESS

#include <e32base.h>

#include <e32des8.h>    // HBufC8

#include "SenDateUtils.h"

#include "SenXmlServiceDescription.h"

#include "SenBaseFragment.h"

#include "SenXmlUtils.h"

#include "sendebug.h"

#include "SenCredential.h"

#include "senproviderpolicy.h"

#include "senservicepolicy.h"

#include "SenFacet.h"

#include "SenXmlUtils.h"

#include <SenServiceConnection.h> // for KErrSenNoEndpoint

namespace

    {

    // Local names for XML element: 

    _LIT8(KServiceDescriptionLocalName, "ServiceDescription");

    _LIT8(KEndpointLocalname,           "Endpoint");

    _LIT8(KContractLocalname,           "Contract");

    _LIT8(KProviderPolicyLocalName,     "ProviderPolicy");

    _LIT8(KServicePolicyLocalName,      "ServicePolicy");

    _LIT8(KClientServicePolicyLocalName, "ClientPolicy");

    _LIT8(KSenIdpProviderIdLocalname,       "ProviderID");

    // Names for XML attributes:

    _LIT8(KNotOnOrAfter,                "notOnOrAfter");

    _LIT8(KFramework,                   "framework");

    _LIT8(KCue,                         "cue");

    _LIT8(KTouch, 						"touch");

    }

EXPORT_C CSenXmlServiceDescription* CSenXmlServiceDescription::NewL()

    {

    CSenXmlServiceDescription* pNew = NewLC();

    CleanupStack::Pop();

    return(pNew) ;

    }

EXPORT_C CSenXmlServiceDescription* CSenXmlServiceDescription::NewLC()

    {

    CSenXmlServiceDescription* pNew =

        new (ELeave) CSenXmlServiceDescription(EXmlServiceDescription);

    CleanupStack::PushL(pNew);

    pNew->ConstructL();

    return pNew;

    }

EXPORT_C void CSenXmlServiceDescription::ConstructL()

    {

    BaseConstructL(NewElementName());

    // Create empty policy

    iProviderPolicy = CSenProviderPolicy::NewL();

    CSenElement& element = iProviderPolicy->AsElement();

    AsElement().AddElementL(element);

    iServicePolicy = CSenServicePolicy::NewL();

    CSenElement& servicePolicyElement = iServicePolicy->AsElement();

    AsElement().AddElementL(servicePolicyElement);

    }

EXPORT_C const TDesC8& CSenXmlServiceDescription::NewElementName()

    {

    return KServiceDescriptionLocalName();

    }

EXPORT_C CSenXmlServiceDescription* CSenXmlServiceDescription::NewL(

                                                const TDesC8& aNamespaceURI)

    {

    CSenXmlServiceDescription* pNew = NewLC(aNamespaceURI);

    CleanupStack::Pop();

    return(pNew) ;

    }

EXPORT_C CSenXmlServiceDescription* CSenXmlServiceDescription::NewLC(

                                                const TDesC8& aNamespaceURI)

    {

    CSenXmlServiceDescription* pNew =

                new (ELeave) CSenXmlServiceDescription(EXmlServiceDescription);

    CleanupStack::PushL(pNew);

    pNew->ConstructL(aNamespaceURI);

    return pNew;

    }

EXPORT_C void CSenXmlServiceDescription::ConstructL(const TDesC8& aNamespaceURI)

    {

    BaseConstructL(aNamespaceURI, NewElementName());

    // create empty policy

    iProviderPolicy = CSenProviderPolicy::NewL();

    CSenElement& element = iProviderPolicy->AsElement();

    AsElement().AddElementL(element);

    iServicePolicy = CSenServicePolicy::NewL();

    CSenElement& servicePolicyElement = iServicePolicy->AsElement();

    AsElement().AddElementL(servicePolicyElement);

    }

EXPORT_C CSenXmlServiceDescription* CSenXmlServiceDescription::NewL(

                                                    const TDesC8& aEndPoint,

                                                    const TDesC8& aContract)

    {

    CSenXmlServiceDescription* pNew = NewLC(aEndPoint, aContract);

    CleanupStack::Pop();

    return(pNew) ;

    }

EXPORT_C CSenXmlServiceDescription* CSenXmlServiceDescription::NewLC(

                                                     const TDesC8& aEndPoint,

                                                     const TDesC8& aContract)

    {

    CSenXmlServiceDescription* pNew =

        new (ELeave) CSenXmlServiceDescription(EXmlServiceDescription);

    CleanupStack::PushL(pNew);

    pNew->ConstructL(aEndPoint, aContract);

    return pNew;

    }

EXPORT_C void CSenXmlServiceDescription::ConstructL(const TDesC8& aEndPoint,

                                                    const TDesC8& aContract)

    {

    BaseConstructL(NewElementName());

    if(aEndPoint.Length()>0)

        {

        SetContentOfL(KEndpointLocalname, aEndPoint);

        }

    if(aContract.Length()>0)

        {

        SetContentOfL(KContractLocalname, aContract);

        }

    // create empty policy

    iProviderPolicy = CSenProviderPolicy::NewL();

    CSenElement& element = iProviderPolicy->AsElement();

    AsElement().AddElementL(element);

    iServicePolicy = CSenServicePolicy::NewL();

    CSenElement& servicePolicyElement = iServicePolicy->AsElement();

    AsElement().AddElementL(servicePolicyElement);

    }

EXPORT_C CSenXmlServiceDescription::CSenXmlServiceDescription(

                                                TDescriptionClassType aType)

:   

    iType(aType),

    iServicePolicy(NULL),   

    iCredential(NULL),

    iNotOnOrAfter(Time::NullTTime()), // sets this session to be valid if read from db

    iProviderPolicy(NULL)

    {

    }

EXPORT_C CSenXmlServiceDescription::~CSenXmlServiceDescription()

    {

    // Bugfix 2004-07-27

    if(iCredential)

        {

        TInt index(KErrNotFound);

        index = iCredentialList.Find(iCredential);

        if(index==KErrNotFound)

            {

            delete iCredential; // otherwise deleted by ResetAndDestroy()

            }

        }

    iCredentialList.ResetAndDestroy(); // owns

    if( iProviderPolicy )

        {

        iProviderPolicy->ExtractElement();

        }    

    delete iProviderPolicy;

     if( iServicePolicy )

        {

        iServicePolicy->ExtractElement();

        }

         delete iServicePolicy;            

    }

EXPORT_C MSenServiceDescription::TDescriptionClassType

                            CSenXmlServiceDescription::DescriptionClassType()

    {

    return iType;

    }

EXPORT_C void CSenXmlServiceDescription::SetAttributesL(const RAttributeArray& aAttributes)

    {

    // Call superclass for namespace attributes only

    CSenBaseFragment::SetAttributesL(aAttributes); 

    // SenXmlUtils::AttrValue returns KNullDesC8 if attribute is not found:

    const TDesC8& id = SenXmlUtils::AttrValue(aAttributes, KFramework);

    if( id.Length()>0 )

        {

        // Add real attribute for ServiceDescription -element. If "framework"

        // attribute already exists, it's value will be overwritten:

        SenXmlUtils::AddAttributeL(AsElement(), KFramework, id); 

        }

    const TDesC8& touch = SenXmlUtils::AttrValue(aAttributes, KTouch);

    if( touch.Length()>0 )

        {

        // Add touch attribute for ServiceDescription -element. If "touch"

        // attribute already exists, it's value will be overwritten:

        CSenElement* elem = &AsElement();

        elem->AddAttrL(KTouch, touch);

        }

    const TDesC8& userInfoPrompt = SenXmlUtils::AttrValue(aAttributes, KSenAttrPromptUserInfo);

    if( userInfoPrompt.Length() > 0 )

        {

        SenXmlUtils::AddAttributeL(AsElement(), KSenAttrPromptUserInfo, userInfoPrompt ); 

        }

    }

EXPORT_C RCredentialList& CSenXmlServiceDescription::Credentials()

    {

    return iCredentialList;

    }

EXPORT_C TBool CSenXmlServiceDescription::Matches( MSenServiceDescription& aOtherServiceDescription )

    {

    TPtrC8 patternEndpoint = aOtherServiceDescription.Endpoint();

    TPtrC8 thisEndpoint = Endpoint();

    if(patternEndpoint.Length()>0)

        {

        if(!(thisEndpoint.Length()>0 && patternEndpoint == thisEndpoint))

            {

            return EFalse;

            }

        }

    TPtrC8 patternContract = aOtherServiceDescription.Contract();

    TPtrC8 thisContract = Contract();

    if(patternContract.Length()>0)

        {

        if(!(thisContract.Length()>0 && patternContract == thisContract))

            {

            return EFalse;

            }

        }

    TBool match(ETrue);

      TInt retVal(KErrNone);

		TRAP(retVal,

		    RFacetArray otherFacets;

		    CleanupClosePushL(otherFacets);

		    aOtherServiceDescription.FacetsL(otherFacets);

		    TPtrC8 facetName;

		    TInt leave(KErrNone);

		    TInt count(otherFacets.Count());

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

		        {

		        facetName.Set(otherFacets[i]->Name());

		        TRAP( leave, HasFacetL(facetName, match); )

		        }

		    otherFacets.ResetAndDestroy();

		    CleanupStack::Pop(); // otherFacets

				);

    return match;

    }

EXPORT_C TPtrC8 CSenXmlServiceDescription::Contract()

    {

    return ContentOf(KContractLocalname());

    }

EXPORT_C TPtrC8 CSenXmlServiceDescription::Endpoint()

    {

    return ContentOf(KEndpointLocalname());

    }

EXPORT_C TPtrC8 CSenXmlServiceDescription::FrameworkId()

    {

    const TDesC8* value = AsElement().AttrValue(KFramework);

    if(value)

        {

        return *value;

        }

    else

        {

        return KNullDesC8();

        }

    }

EXPORT_C TPtrC8 CSenXmlServiceDescription::FrameworkVersion()

    {

    return KNullDesC8();

    }

EXPORT_C void CSenXmlServiceDescription::SetContractL(const TDesC8& aContract)

    {

    SetContentOfL(KContractLocalname(), aContract);

    }

EXPORT_C void CSenXmlServiceDescription::SetEndPointL(const TDesC8& aEndPoint)

    {

    SetContentOfL(KEndpointLocalname(), aEndPoint);

    }

EXPORT_C void CSenXmlServiceDescription::SetFrameworkIdL(const TDesC8& aFrameworkId)

    {

    if ( aFrameworkId != KNullDesC8 )

        {

        // overwrites the value of "framework" attribute, if such attribute exists

        SenXmlUtils::AddAttributeL(AsElement(), KFramework, aFrameworkId);

        }

    else

        {

        // If there would not have been RemoveAttributeL() method, 

        // then AddAtributeL(KNullDesC8) could have been used

        delete SenXmlUtils::RemoveAttributeL(AsElement(), KFramework);

        }

    }

EXPORT_C HBufC8* CSenXmlServiceDescription::AsXmlL()

    {

    return AsElement().AsXmlL();

    }

EXPORT_C HBufC* CSenXmlServiceDescription::AsXmlUnicodeL()

    {

    return AsElement().AsXmlUnicodeL();

    }

EXPORT_C void CSenXmlServiceDescription::WriteAsXMLToL(RWriteStream& aWriteStream)

    {

    AsElement().WriteAsXMLToL(aWriteStream);

    }

EXPORT_C void CSenXmlServiceDescription::StartElementL(const TDesC8& aNsUri,

                                                       const TDesC8& aLocalName,

                                                       const TDesC8& aQName,

                                                       const RAttributeArray& aAttributes)

    {

    switch (iState)

        {

        case KStateSave: // IOP(!)

            {

            if(aLocalName.Compare(KCredentialsName) == 0)

                {

                iState = KStateParsingCredentials;

                TPtrC8 attValue = SenXmlUtils::AttrValue(aAttributes, 

                                                    KNotOnOrAfter);

                if(attValue.Length()>0)

                    {

                    iNotOnOrAfter = SenDateUtils::FromXmlDateTimeL(attValue);

                    }

                }

            else if(aLocalName.Compare(KProviderPolicyLocalName) == 0)

                {

                iState = KStateParsingProviderPolicy;

                TPtrC8 prefix(KNullDesC8);

                if(aQName.Length()>0)

                    {

                    TInt colon = aQName.Locate(':');

                    if(colon>0) // Note: 0 also treated as no prefix

                        {

                        prefix.Set(aQName.Ptr(), colon);

                        }

                    }

                iProviderPolicy->AsElement().SetNamespaceL(prefix, aNsUri);

                DelegateParsingL(*iProviderPolicy);

                }

             else if(aLocalName.Compare(KServicePolicyLocalName) == 0)

                {

                iState = KStateParsingServicePolicy;

                TPtrC8 prefix(KNullDesC8);

                if(aQName.Length()>0)

                    {

                    TInt colon = aQName.Locate(':');

                    if(colon>0) // Note: 0 also treated as no prefix

                        {

                        prefix.Set(aQName.Ptr(), colon);

                        }

                   }

                iServicePolicy->AsElement().SetNamespaceL(prefix, aNsUri);

                DelegateParsingL(*iServicePolicy);

                }

            else

                {

                CSenDomFragment::StartElementL( aNsUri,

                                                aLocalName,

                                                aQName,

                                                aAttributes );

                // For each endpoint, preserve the "cue" attribute

                if( aLocalName == KEndpointLocalname )

                    {

                    const TDesC8& cue = SenXmlUtils::AttrValue(aAttributes, KCue);

                    CSenElement* pEndpointElement = AsElement().Element( aLocalName );

                    if( cue.Length() > 0 && pEndpointElement)

                        {

                        SenXmlUtils::AddAttributeL(*pEndpointElement, KCue, cue );

                        }

                    }

                }

            break;

            }

        case KStateParsingCredentials:

            {

            iState = KStateParsingSingleCredential;

            // see destructor: iCredentialList.ResetAndDestroy(); // owns

            iCredential = CSenCredential::NewL( aNsUri,

                                                aLocalName,

                                                aQName,

                                                aAttributes,

                                                AsElement());

            iCredential->SetValidUntil(iNotOnOrAfter);

            DelegateParsingL(*iCredential);

            break;

            }

        default: // iState is KStateIgnore or some other..

            {

            // 2005-11: changed

            if(aLocalName == KServiceDescriptionLocalName())

                {

                SetAttributesL(aAttributes);

                }

            CSenDomFragment::StartElementL( aNsUri,

                                            aLocalName,

                                            aQName,

                                            aAttributes);

            }

        }

    }

EXPORT_C void CSenXmlServiceDescription::EndElementL(const TDesC8& aNsUri,

                                                     const TDesC8& aLocalName,

                                                     const TDesC8& aQName )

    {

    switch (iState)

        {

        case KStateParsingCredentials:

            {

            if(aLocalName == KCredentialsName)

                {

                iState = KStateSave;

                }

            } break;

        case KStateParsingSingleCredential:

            {

            iCredential->DetachL();

            iCredentialList.Append(iCredential);

            if(aLocalName == KCredentialsName)

                {

                iState = KStateIgnore;

                }

            else

                {

                iState = KStateParsingCredentials;

                }

            break;

            }

        case KStateParsingServicePolicy:

            {

//            if(aLocalName == KServicePolicyLocalName)

                {

                iState = KStateSave;

                }

            } break;            

        case KStateParsingProviderPolicy:

            {

            iState = KStateSave;

            } break;

        default:

            {

            CSenDomFragment::EndElementL(aNsUri, aLocalName, aQName);

            }

        }

    }

// From Provider Policy:

// Setter for Internet Access Point (IAP) ID

EXPORT_C void CSenXmlServiceDescription::SetIapIdL(TUint32 aIapId)

    {

    iProviderPolicy->SetIapIdL(aIapId);