/*

* Copyright (c) 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 <s32strm.h> // RWriteStream

#include <SenXmlReader.h>

#include <SenXmlUtils.h>

#include <SenTransportProperties.h>

#include "senpropertiesfragment.h"

#include "SenBaseAttribute.h"

#include <xml/attribute.h> // From syslibs, needed for RAttributeArray

#include "senlogger.h"

//#include "senxmldebug.h"

namespace

    {

    _LIT8(KCid,"cid");

    }

EXPORT_C CSenTransportProperties* CSenTransportProperties::NewL()

    {

    CSenTransportProperties* pNew = NewLC();

    CleanupStack::Pop(); // pNew

    return pNew;

    }

EXPORT_C CSenTransportProperties* CSenTransportProperties::NewLC()

    {

    CSenTransportProperties* pNew = new (ELeave) CSenTransportProperties;

    CleanupStack::PushL(pNew);

    // omit parsing by passing zero-length descriptor

    pNew->BaseConstructL(KSenXmlPropertiesLocalname,

                         KNullDesC8,

                         NULL);

    return pNew;

    }

EXPORT_C CSenTransportProperties* CSenTransportProperties::NewL(const TDesC8& aXmlUtf8,

                                                               CSenXmlReader& aParser)

    {

    CSenTransportProperties* pNew = NewLC(aXmlUtf8, aParser);

    CleanupStack::Pop(); // pNew

    return pNew;

    }

EXPORT_C CSenTransportProperties* CSenTransportProperties::NewLC(const TDesC8& aXmlUtf8,

                                                                CSenXmlReader& aParser)

    {

    CSenTransportProperties* pNew = new (ELeave) CSenTransportProperties;

    CleanupStack::PushL(pNew);

    // parse the XML document  descriptor into DOM fragment

    pNew->BaseConstructL(KSenXmlPropertiesLocalname,

                         aXmlUtf8,

                         &aParser);

    return pNew;

    }

EXPORT_C CSenTransportProperties* CSenTransportProperties::NewL(const CSenElement& aElement)

    {

    CSenTransportProperties* pNew = NewLC(aElement);

    CleanupStack::Pop(); // pNew

    return pNew;

    }

EXPORT_C CSenTransportProperties* CSenTransportProperties::NewLC(const CSenElement& aElement)

    {

    CSenTransportProperties* pNew = new (ELeave) CSenTransportProperties;

    CleanupStack::PushL(pNew);

    // parse the XML document  descriptor into DOM fragment

    pNew->BaseConstructL(aElement);

    return pNew;

    }

EXPORT_C void CSenTransportProperties::SetReader(CSenXmlReader& aReader)

    {

    CSenXmlProperties::SetReader(aReader);

    }      

EXPORT_C MSenProperties::TSenPropertiesClassType CSenTransportProperties::PropertiesClassType() 

    {

    return ESenTransportProperties;

    }

EXPORT_C void CSenTransportProperties::WriteToL(RWriteStream& aWriteStream)

    {

    CSenXmlProperties::WriteToL(aWriteStream);

    }

EXPORT_C void CSenTransportProperties::ReadFromL(const TDesC8& aBuffer)

    {

    CSenXmlProperties::ReadFromL(aBuffer);

    }    

EXPORT_C HBufC8* CSenTransportProperties::AsUtf8L()

    {

    return CSenXmlProperties::AsUtf8L();

    }

EXPORT_C HBufC8* CSenTransportProperties::AsUtf8LC()

    {

    return CSenXmlProperties::AsUtf8LC();

    }

EXPORT_C TBool CSenTransportProperties::IsSafeToCast(TSenPropertiesClassType aClass)

    {

    if ( aClass == MSenProperties::ESenTransportProperties )

        {

        return ETrue;

        }

    else

        {

        return CSenXmlProperties::IsSafeToCast(aClass);

        }

    }      

EXPORT_C TInt CSenTransportProperties::SetPropertyL(const TDesC8& aName,

                                                       const TDesC8& aValue)

    {

    return CSenXmlProperties::SetPropertyL(aName, aValue);

    }

EXPORT_C TInt CSenTransportProperties::PropertyL(const TDesC8& aName,

                                                   TPtrC8& aValue)

    {

    return CSenXmlProperties::PropertyL(aName, aValue);

    }

EXPORT_C TInt CSenTransportProperties::SetIntPropertyL(const TDesC8& aName,

                                                       const TInt aValue)

    {

    return CSenXmlProperties::SetIntPropertyL(aName, aValue);

    }

EXPORT_C TInt CSenTransportProperties::IntPropertyL(const TDesC8& aName,

                                                    TInt& aValue)

    {

    return CSenXmlProperties::IntPropertyL(aName, aValue);

    }

EXPORT_C TInt CSenTransportProperties::SetBoolPropertyL(const TDesC8& aName,

                                                        const TBool aValue)

    {

    return CSenXmlProperties::SetBoolPropertyL(aName, aValue);

    }

EXPORT_C TInt CSenTransportProperties::BoolPropertyL(const TDesC8& aName,

                                                     TBool& aValue)

    {

    return CSenXmlProperties::BoolPropertyL(aName, aValue);

    }

EXPORT_C TInt CSenTransportProperties::SetOmittedL(const TDesC8& aName, TBool aValue)

    {

    return CSenXmlProperties::SetOmittedL(aName, aValue);

    }

EXPORT_C TInt CSenTransportProperties::RemovePropertyL(const TDesC8& aName)

    {

    return CSenXmlProperties::RemovePropertyL(aName);

    }

EXPORT_C CSenTransportProperties::~CSenTransportProperties()

    {

    }

EXPORT_C void CSenTransportProperties::BaseConstructL(const TDesC8& aLocalname, 

                                                 const TDesC8& aXml,

                                                 CSenXmlReader* aParser)

    {

    CSenXmlProperties::BaseConstructL(aLocalname, aXml, aParser);

    }

EXPORT_C void CSenTransportProperties::BaseConstructL(const TDesC8& aNamespace, 

                                                 const TDesC8& aLocalname, 

                                                 const TDesC8& aXml,

                                                 CSenXmlReader* aParser)

    {

    CSenXmlProperties::BaseConstructL(aNamespace, aLocalname, aXml, aParser);

    }

void CSenTransportProperties::BaseConstructL(const TDesC8& aNamespace, 

                                                 const TDesC8& aLocalname, 

                                                 const TDesC8& aQualifiedName, 

                                                 const TDesC8& aXml,

                                                 CSenXmlReader* aParser)

    {

    CSenXmlProperties::BaseConstructL(aNamespace, aLocalname, aQualifiedName, aXml, aParser);

    }

EXPORT_C void CSenTransportProperties::BaseConstructL(const CSenElement& aElement)

    {

    CSenXmlProperties::BaseConstructL(aElement);

    }

EXPORT_C CSenTransportProperties::CSenTransportProperties()

: iFileAttachmentNum(0)

    {

    }

EXPORT_C TInt CSenTransportProperties::SetPropertyL(const TDesC8& aName,

                                                    const TDesC8& aValue,

                                                    const TDesC8& aType)

    {

    return CSenXmlProperties::SetPropertyL(aName, aValue, aType);

    }

EXPORT_C TInt CSenTransportProperties::PropertyL(const TDesC8& aName,

                                                    TPtrC8& aValue,

                                                    TPtrC8& aType)

    {

    return CSenXmlProperties::PropertyL(aName, aValue, aType);

    }

//common properties

EXPORT_C TInt CSenTransportProperties::IapIdL(TUint32& aCurrentIapId)

    {

    TPtrC8 value;

    TInt retVal = PropertyL(KIapIdLocalName, value);

    if ( retVal == KErrNone )

        {

        TLex8 lex(value);

        retVal = lex.Val(aCurrentIapId, EDecimal);

        }

    if(aCurrentIapId > 0) return retVal;

    else return KErrNotFound;

    }

EXPORT_C void CSenTransportProperties::SetIapIdL(TUint32 aIapId)

    {

    TBuf8<128> buf;

    buf.AppendFormat(_L8("%u"), aIapId);

    SetPropertyL(KIapIdLocalName, buf);

    }

// Setter for Service Network Access Point (SNAP) ID

EXPORT_C void CSenTransportProperties::SetSnapIdL(TUint32 aSnapId)

    {

	TBuf8<128> buf;

    buf.AppendFormat(_L8("%u"), aSnapId);

    SetPropertyL(KSnapIdLocalName, buf);

    }

// Getter for SNAP ID

EXPORT_C TInt CSenTransportProperties::SnapIdL(TUint32& aCurrentSnapId)

    {

    TPtrC8 value;

    TInt retVal = PropertyL(KSnapIdLocalName, value);

    if ( retVal == KErrNone )

        {

        TLex8 lex(value);

        retVal = lex.Val(aCurrentSnapId, EDecimal);

        }

    if(aCurrentSnapId > 0) return retVal;

    else return KErrNotFound;

    }

EXPORT_C TInt CSenTransportProperties::ProxyPortL(TInt& aProxyPort)

    {

    TPtrC8 value;

    TInt retVal = PropertyL(KProxyPortLocalName, value);

    if ( retVal == KErrNone )

        {

        TLex8 lex(value);

        TUint proxyPort;

        retVal = lex.Val(proxyPort, EDecimal);

        if ( retVal == KErrNone )

            {

            aProxyPort = proxyPort;

            }

        }

    return retVal;

    }

EXPORT_C void CSenTransportProperties::SetProxyPortL(TInt aProxyPort)

    {

    SetIntPropertyL(KProxyPortLocalName, aProxyPort);

    }

EXPORT_C TInt CSenTransportProperties::ProxyHostL(TPtrC8& aProxyHost)

    {

    return PropertyL(KProxyHostLocalName, aProxyHost);

    }

EXPORT_C void CSenTransportProperties::SetProxyHostL(const TDesC8& aProxyHost)

    {

    SetPropertyL(KProxyHostLocalName, aProxyHost);

    }

EXPORT_C TInt CSenTransportProperties::ProxyUsageL(TBool& aValue)

    {

    return BoolPropertyL(KProxyUsageLocalName, aValue);

    }

EXPORT_C void CSenTransportProperties::SetProxyUsageL(TBool aProxyUsage)

    {

    SetBoolPropertyL(KProxyUsageLocalName, aProxyUsage);

    }

EXPORT_C TInt CSenTransportProperties::SecureDialogL(TBool& aValue)

    {

    return BoolPropertyL(KSecureDialogLocalName, aValue);

    }

EXPORT_C void CSenTransportProperties::SetSecureDialogL(TBool aSecureDialog)

    {

    SetBoolPropertyL(KSecureDialogLocalName, aSecureDialog);

    }

/*

EXPORT_C TInt CSenTransportProperties::IAPDialogL(TBool& aValue)

    {

    return BoolPropertyL(KSenIAPDoNotPrompt, aValue);

    }

EXPORT_C void CSenTransportProperties::SetIapDialogL(TBool aIapDialog)

    {

    SetBoolPropertyL(KSenIAPDoNotPrompt, aIapDialog);

    }

*/

EXPORT_C TInt CSenTransportProperties::UserAgentL(TPtrC8& aUserAgent)

    {

    return PropertyL(KUserAgentLocalName, aUserAgent);

    }

EXPORT_C void CSenTransportProperties::SetUserAgentL(const TDesC8& aUserAgent)

    {

    SetPropertyL(KUserAgentLocalName, aUserAgent);

    }

EXPORT_C TInt CSenTransportProperties::DeviceIDL(TPtrC8& aDeviceID)

    {

    return PropertyL(KDeviceIDLocalName, aDeviceID);

    }

EXPORT_C void CSenTransportProperties::SetDeviceIDL(const TDesC8& aDeviceID)

    {

    SetPropertyL(KDeviceIDLocalName, aDeviceID);

    }    

EXPORT_C TInt CSenTransportProperties::SoapActionL(TPtrC8& aAction)

    {

    return PropertyL(KSoapActionLocalName, aAction);

    }

EXPORT_C void CSenTransportProperties::SetSoapActionL(const TDesC8& aAction)

    {

    SetPropertyL(KSoapActionLocalName, aAction);

    }    

EXPORT_C void CSenTransportProperties::ApplyBindingL(TSOAPVersion /*aSoapVersion*/)

    {

    }

EXPORT_C TInt CSenTransportProperties::DownloadFolderL(TPtrC8& aDownloadFolder)

    {

    return PropertyL(KDownloadFolderLocalName, aDownloadFolder);

    }

EXPORT_C void CSenTransportProperties::SetDownloadFolderL(const TDesC8& aDownloadFolder)

    {

    SetPropertyL(KDownloadFolderLocalName, aDownloadFolder);

    }

EXPORT_C TInt CSenTransportProperties::FileAttachmentL(const TDesC8& aCid, HBufC8*& aFileName)

    {

    TLSLOG_L(KSenUtilsLogChannel, KMinLogLevel, "CSenTransportProperties::FileAttachmentL:");

    TLSLOG_FORMAT((KSenUtilsLogChannel, KMinLogLevel, _L8("- CID: '%S'"), &aCid));        

//    _LIT8(KAttachment, "Attachment");

    TPtrC8 pFileAttachments;

    TInt retVal( KErrNotFound );

    retVal = PropertyL( KFileAttachmentsLocalName, pFileAttachments );    

    if ( retVal == KErrNone )

        {

        CSenXmlReader* reader = CSenXmlReader::NewL(KXmlParserMimeType); // use libxml2 sax parser

        CleanupStack::PushL( reader );

        CSenDomFragment* pFragment = CSenDomFragment::NewL();

        CleanupStack::PushL( pFragment );

        pFragment->SetReader( *reader );    

        pFragment->BuildFrom( pFileAttachments );  

        if (aFileName)

            {

            delete aFileName;

            aFileName = NULL;

            }

        RPointerArray<CSenElement>& elements = pFragment->AsElement().ElementsL();

        TInt count(elements.Count());

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

            {

            CSenElement* pElement = elements[i];

            TLSLOG_FORMAT((KSenUtilsLogChannel, KNormalLogLevel, _L8("- Processing file attachment element: '%S'"), &pElement->LocalName()));        

            RPointerArray<CSenBaseAttribute>& attributes = pElement->AttributesL();

            TInt attrCount(attributes.Count());

            for ( TInt j=0; j<attrCount; j++ )            

                {

                TPtrC8 name = attributes[j]->Name();

                TPtrC8 value = attributes[j]->Value();

                TLSLOG_FORMAT((KSenUtilsLogChannel, KNormalLogLevel, _L8("- Processing file attachment attribute, name: '%S', value: '%S'"), &name, &value));        

                if ( name == KCid && value == aCid )

                    {

                    TLSLOG_L(KSenUtilsLogChannel, KNormalLogLevel, "- Filename for CID found.");

                    aFileName = HBufC8::NewL( pElement->Content().Length() );

                    TPtr8 aFileNameDes = aFileName->Des();                

                    aFileNameDes.Append( pElement->Content() );

                    retVal = KErrNone;

                    break; // no need to check rest of the attributes

                    }

                }

                // if ( aFileName ) break; // no need to check rest of the child elements

            }

        CleanupStack::PopAndDestroy(pFragment);

        CleanupStack::PopAndDestroy(reader);

        }

    return retVal;

        /*

        HBufC8* pLocalName = HBufC8::NewLC(KAttachment().Length()+aCid.Length());

        TPtr8 localNameDes = pLocalName->Des();

        localNameDes.Append(KAttachment);

        localNameDes.Append(aCid);

        CSenElement* pElement = pFragment->AsElement().Element(*pLocalName);

        if(pElement)

            {

            if (aFileName)

                {

                delete aFileName;

                aFileName = NULL;

                }

            aFileName = HBufC8::NewL(pElement->Content().Length());

            TPtr8 aFileNameDes = aFileName->Des();                

            aFileNameDes.Append(pElement->Content());

            CleanupStack::PopAndDestroy(pLocalName);

            CleanupStack::PopAndDestroy(pFragment);

            CleanupStack::PopAndDestroy(reader);

            return KErrNone;

            }

        else

            {

            CleanupStack::PopAndDestroy(pLocalName);

            CleanupStack::PopAndDestroy(pFragment);

            CleanupStack::PopAndDestroy(reader);

            return KErrNotFound;

            }

        }

        */            

    }

EXPORT_C TInt CSenTransportProperties::SetFileAttachmentL(const TDesC8& aCid, const TDesC8& aFileName)

    {

    TLSLOG_L(KSenUtilsLogChannel, KMinLogLevel, "CSenTransportProperties::SetFileAttachmentL:");

    TLSLOG_FORMAT((KSenUtilsLogChannel, KMinLogLevel, _L8("- CID: '%S'"), &aCid));        

    TBuf<32> num;

    num.AppendNum( iFileAttachmentNum );

    _LIT8(KAttachments,"Attachments");

    _LIT8(KAttachment,"Attachment");

    TPtrC8 pFileAttachments;

    TInt err(KErrNone);

    err = PropertyL(KFileAttachmentsLocalName, pFileAttachments);

    if (err != KErrNotFound)

        {

        // Add to existing <Attachements/> fragment:

        CSenXmlReader* reader = CSenXmlReader::NewL(KXmlParserMimeType); // use libxml2 sax parser

        CleanupStack::PushL(reader);

        CSenDomFragment* pFragment = CSenDomFragment::NewL();

        CleanupStack::PushL(pFragment);

        pFragment->SetReader(*reader);    

        pFragment->BuildFrom(pFileAttachments);  

        // --- //

        HBufC8* pLocalName = HBufC8::NewLC( KAttachment().Length() + num.Length() );

        TPtr8 localNameDes = pLocalName->Des();

        localNameDes.Append( KAttachment );

        localNameDes.Append( num );

        CSenElement* pElement = pFragment->AsElement().Element(*pLocalName);

        if (pElement)  

            {

            CleanupStack::PopAndDestroy(pLocalName);

            CleanupStack::PopAndDestroy(pFragment);

            CleanupStack::PopAndDestroy(reader);

            return KErrAlreadyExists; 

            }

        else

            {

            CSenElement& pElement = pFragment->AsElement().AddElementL(*pLocalName);

            pElement.SetContentL(aFileName);

            SenXmlUtils::AddAttributeL(pElement, KCid, aCid );	//CodeScannerWarnings

            HBufC8* pFragmentAsXml = pFragment->AsXmlL();

            CleanupStack::PushL(pFragmentAsXml);

            SetPropertyL( KFileAttachmentsLocalName, *pFragmentAsXml );

            CleanupStack::PopAndDestroy( pFragmentAsXml );

            }

        CleanupStack::PopAndDestroy(pLocalName);

        CleanupStack::PopAndDestroy(pFragment);