/*
* 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 <utf.h>

#include "SenXmlConstants.h"
#include "SenXmlUtils.h"
#include "SenElement.h"
#include "SenBaseAttribute.h"

#ifdef SYMBIAN_SECURE_ECOM 
    // for 2.8, 3.0 or newer:
    #include <xml/attribute.h> // needed for RAttributeArray
#else // for 2.6 or olde
    #include "Attribute.h"
#endif

using namespace Xml;

EXPORT_C HBufC8* SenXmlUtils::ToUtf8LC(const TDesC16& aUnicodeString)
    {
    // 6 times multiplier is the worst case...
    HBufC8* pBuf8 = HBufC8::NewLC(6 * aUnicodeString.Length());
    TPtr8 des8 = pBuf8->Des();
    TInt ret = CnvUtfConverter::ConvertFromUnicodeToUtf8(des8, aUnicodeString);
    User::LeaveIfError(ret);

    // Shrink allocated memory if possible
    HBufC8* pReallocBuf8 = pBuf8->ReAlloc(pBuf8->Length());
    if (pReallocBuf8 != NULL)
        {
        // It could reallocate
        CleanupStack::Pop(); // pop pBuf8;
        CleanupStack::PushL(pReallocBuf8);
        pBuf8 = pReallocBuf8;
        }
    return pBuf8;
    }

EXPORT_C HBufC16* SenXmlUtils::ToUnicodeLC(const TDesC8& aUtf8String)
    {
    HBufC16* pBuf = HBufC16::NewLC(2 * aUtf8String.Length());
    TPtr16 des = pBuf->Des();
    TInt ret = CnvUtfConverter::ConvertToUnicodeFromUtf8(des, aUtf8String);
    User::LeaveIfError(ret);
    return pBuf;
    }


EXPORT_C TBool SenXmlUtils::StartsWith(const TDesC8& aDes,
                                       const TDesC8& aPrefix)
    {
    if (aDes.Length() < aPrefix.Length())
        {
        return EFalse;
        }
    else
        {
        return (aDes.Left(aPrefix.Length()) == aPrefix);
        }
    }

EXPORT_C TBool SenXmlUtils::EndsWith(const TDesC8& aDes,
                                     const TDesC8& aPostfix)
    {
    if (aDes.Length() < aPostfix.Length())
        {
        return EFalse;
        }
    else
        {
        return (aDes.Right(aPostfix.Length()) == aPostfix);
        }
    }

EXPORT_C TPtrC8 SenXmlUtils::NsPrefix(const TDesC8& aQName)
    {
    TInt colonPos = aQName.Find(KSenColon);
    if (colonPos < 0)
        {
        return KNullDesC8();
        }
    else
        {
        return aQName.Left(colonPos);
        }
    }

EXPORT_C TPtrC8 SenXmlUtils::LocalName(const TDesC8& aQName)
    {
    TInt colonPos = aQName.Find(KSenColon);
    if (colonPos < 0)
        {
        return aQName;
        }
    else
        {
        return aQName.Mid(colonPos + 1);
        }
    }

EXPORT_C TPtrC8 SenXmlUtils::AttrValue( const RAttributeArray& aAttributes,
                                        const TDesC8& aAttrName)
    {
    TInt count(aAttributes.Count());
    for (TInt i=0; i<count;i++)
        {
        if (aAttributes[i].Attribute().LocalName().DesC() == aAttrName)
            {
            return aAttributes[i].Value().DesC();
            }
        }
    return KNullDesC8();
    }

//EXPORT_C TPtrC8 SenXmlUtils::AttrType(const RAttributeArray& aAttributes,
//                                        const TDesC8& aAttrName)
//  {
//  TInt count(aAttributes.Count());
//  for (TInt i=0; i<count;i++)
//      {
//      if (aAttributes[i].Attribute().LocalName().DesC() == aAttrName)
//          {
//          return aAttributes[i].Type().DesC();
//          }
//      }
//  return KNullDesC8();
//  }

EXPORT_C void SenXmlUtils::BuildQNameL( const TDesC8& aPrefix,
                                        const TDesC8& aLocalName,
                                        HBufC8*& aQName)
    {
    aQName = HBufC8::NewLC( aPrefix.Length()+KSenColon().Length()
                            +aLocalName.Length() );
    if (aPrefix != KNullDesC8)
        {
        aQName->Des().Append(aPrefix);
        aQName->Des().Append(KSenColon);
        }
    aQName->Des().Append(aLocalName);
    CleanupStack::Pop();

    }

EXPORT_C TBool SenXmlUtils::EncodeHttpCharactersL(const TDesC8& aOriginal,
                                                     HBufC8*& aEncoded)
    {
    TBool retVal = EFalse;
    delete aEncoded;
    aEncoded = NULL;

    if (aOriginal == KNullDesC8)
        {
        return retVal;
        }
    TPtrC8 tokens[] =
        {
        KSenEscapedAmp(),
        KSenEscapedApos(),
        KSenEscapedDblQuot(),
        KSenEscapedGt(),
        KSenEscapedLt()
        };
    TText16 tokenChars[] =
        {
        '&',
        '\'',
        '\"',
        '>',
        '<'
        };
    
    // Replace escaped characters, if any
    for (TInt i = 0; i < aOriginal.Length(); i++)
        {
        TBool foundChar = EFalse;
        for (TUint j = 0; j < (sizeof(tokenChars) / sizeof(TText16)); j++)
            {
            if (aOriginal[i] == tokenChars[j])
                {
                if (!aEncoded)
                    {
                    aEncoded =
                        HBufC8::NewL(aOriginal.Length() * KSenMaxXmlEscapedLength);
                    aEncoded->Des().Append(aOriginal.Left(i));
                    }
                foundChar = ETrue;
                aEncoded->Des().Append(tokens[j]);
                retVal = ETrue; // indicate, that encoding was done
                break;
                }
            }
        if (!foundChar)
            {
            if (aEncoded)
                {
                
                aEncoded->Des().Append(aOriginal[i]);
                }
            }
        }

    return retVal;
    }

EXPORT_C HBufC8* SenXmlUtils::EncodeHttpCharactersLC( const TDesC8& aOriginal )
    {
    HBufC8* pDecoded = NULL;
    if (!EncodeHttpCharactersL(aOriginal, pDecoded))
        {
        // if anything was allocated (never in current implementation)
        delete pDecoded; 
        pDecoded = NULL;

        // make a copy of original, so that caller always knows that
        // there is something from which to take ownership.
        pDecoded = aOriginal.AllocL();
        }
    CleanupStack::PushL(pDecoded);
    return pDecoded;
    }

TBool SenXmlUtils::ReplaceAll(TPtr8 aDestination,
                              const TDesC8& aFrom,
                              const TDesC8& aTo)
    {
    TInt retVal(EFalse);
    
    TInt pos = aDestination.Find(aFrom);
    if (pos != KErrNotFound) retVal = ETrue;
    
    while (pos != KErrNotFound)
        {
        aDestination.Replace(pos,aFrom.Length(),aTo);
        pos = aDestination.Find(aFrom);
        }

    return retVal;
    }
/**
 * DecodeHttpCharactersL() returns ETrue, if any XML escaping
 * (some Basic Entity) character-sequence was decoded.
 *
 * Note that aDecoded points to a copy of the original string
 * even if there were no basic entities to decode. Otherwise,
 * it points to a newly allocated descriptor, where some
 * basic entity or entities has been decoded (replaced) from
 * aOriginal descriptor.
 * 
 */
EXPORT_C TBool SenXmlUtils::DecodeHttpCharactersL( const TDesC8& aOriginal,
                                                   HBufC8*& aDecoded )
    {
    delete aDecoded;
    aDecoded = NULL;

    // make a copy of the original
    aDecoded = aOriginal.AllocL();

    TBool retVal(EFalse);


    // replace all five basic entities with XML escaping counterpart,
    // if found.
    if (ReplaceAll(aDecoded->Des(), KSenEscapedAmp(), KSenAmpersandDesC8()))
        {
        retVal = ETrue;
        }
    if (ReplaceAll(aDecoded->Des(), KSenEscapedApos(), KSenAposDesC8()))
        {
        retVal = ETrue;
        }
    if (ReplaceAll(aDecoded->Des(), KSenEscapedDblQuot(), KSenDblQuotDesC8()))
        {
        retVal = ETrue;
        }
    if (ReplaceAll(aDecoded->Des(), KSenEscapedGt(), KSenGtDesC8()))
        {
        retVal = ETrue;
        }
    if (ReplaceAll(aDecoded->Des(), KSenEscapedLt(), KSenLtDesC8()))
        {
        retVal = ETrue;
        }

    return retVal;
    }

/**
* In Symbian OS v9.1, see
* Location: EscapeUtils.h 
* Link against: inetprotutil.lib 
*
*/
EXPORT_C HBufC8* SenXmlUtils::DecodeHttpCharactersLC(const TDesC8& aOriginal)
    {
    HBufC8* pDecoded = NULL;

    // Attempt to decode. Note, that even if no Basic Entities were
    // decoded into XML escaping characters (&,',",< or >), this
    // function will return a pointer to a copy of the original
    // descriptor.
    DecodeHttpCharactersL(aOriginal, pDecoded);

    // Push to cleanup stack
    CleanupStack::PushL(pDecoded);
    return pDecoded;
    }

EXPORT_C HBufC8* SenXmlUtils::AllocAttrValueL(  const RAttributeArray& apAttrs,
                                                const TDesC8& aAttrName )
    {
    TPtrC8 p = AttrValue(apAttrs, aAttrName);
    if (p == KNullDesC8)
        {
        return NULL;
        }
    else
        {
        return p.AllocL();
        }
    }

// the non-optimized version:
/* 
EXPORT_C void SenXmlUtils::LeaveOnXmlEscapesL(const TDesC8& aCandidate)
    {
    HBufC8* pValidator = NULL;
    
    // check if there are any XML escaping character by calling
    // basic entity encoding function. 
    TBool containsEscapes = SenXmlUtils::EncodeHttpCharactersL(aCandidate, pValidator);

    delete pValidator;

    if(containsEscapes)
        {
        // some XML-escaping character was found.
        // Indicate with Leave, that the given 
        // aChars descriptor is illegal, because
        // it contained invalid characters
        User::Leave(KErrSenInvalidCharacters);
        }
    }
*/

// Optimized, but not throughoutly tested version.
// Based on UPnP project optimizations (2005-10-13).

EXPORT_C void SenXmlUtils::LeaveOnXmlEscapesL(const TDesC8& aCandidate)
    {
    // these are the escapes which are searched after
    TText16 tokenChars[] =
        {
        '&',
        '\'',
        '\"',
        '>',
        '<'
        };
    
    // Search for XML escaping characters
    for (TInt i=0; i<aCandidate.Length(); i++)
        {
        for (TUint j = 0; j < (sizeof(tokenChars) / sizeof(TText16)); j++)
            {
            if (aCandidate[i] == tokenChars[j])
                {
                // some XML-escaping character was found.
                // Indicate with Leave, that the given 
                // aChars descriptor is illegal, because
                // it contained invalid characters
                User::Leave(KErrSenInvalidCharacters);
                }
            }
        }
    }

void SenXmlUtils::LeaveOnInvalidElementNameL(const TDesC8& aCandidate)
    {
    if (aCandidate == KNullDesC8)
        {
        User::Leave(KErrSenZeroLengthDescriptor);
        }
    SenXmlUtils::LeaveOnXmlEscapesL(aCandidate);
    }

EXPORT_C CSenBaseAttribute* SenXmlUtils::RemoveAttributeL(CSenElement& aElement,
                                                          const TDesC8& aAttrName)
    {
    CSenBaseAttribute* pAttribute = SenXmlUtils::FindAttrL( aElement, aAttrName );
    if ( pAttribute )
        {
        RPointerArray<CSenBaseAttribute>& attributes = aElement.AttributesL();
        
        TInt index(attributes.Find(pAttribute));
        if ( index != KErrNotFound )
            {
            attributes.Remove(index); // release ownership
            }
        else
            {
            // should never occur:
            pAttribute = NULL; // ownership could not be transferred..
            }
        }

    return pAttribute;
    }

EXPORT_C CSenBaseAttribute* SenXmlUtils::RemoveAttributeL(CSenElement& aElement,
                                                          CSenBaseAttribute* apAttribute)
    {
    return SenXmlUtils::RemoveAttributeL(aElement, apAttribute->Name());
    }
    
CSenBaseAttribute* SenXmlUtils::FindAttrL( CSenElement& aElement,
                                           const TDesC8& aName )
    {
    RPointerArray<CSenBaseAttribute>& attributes = aElement.AttributesL();
    
    TInt count(attributes.Count());
    for (TInt i = 0; i < count; i++)
        {
        CSenBaseAttribute* pAttribute = attributes[i];
        if ( pAttribute->Name() == aName )
            {
            return pAttribute;
            }
        }

    return NULL;
    }

EXPORT_C const TDesC8& SenXmlUtils::AddAttributeL(CSenElement& aElement,
                                                  const TDesC8& aQName,
                                                  const TDesC8& aLocalName,
                                                  const TDesC8& aValue)
    {
    // first we check for possible namespace declarations...
    if ( aQName == KSenXmlns || aLocalName == KSenXmlns)
        {
        // this is a default name space declaration
        aElement.SetNamespaceL(aValue);
        }
    else if (aLocalName == aElement.NsPrefix())
        {
        //we have a new declaration for the namespace of this element
        aElement.SetNamespaceL(aLocalName, aValue);
        }
    else if(aQName.Find(KSenXmlNsAttNamePlusColon) == 0)
        {
        // we have an additional namespace declaration
        aElement.AddNamespaceL(aLocalName, aValue);
        }
    else
        {
        // we have a real attribute!
        CSenBaseAttribute* pAttribute = CSenBaseAttribute::NewL(aQName,
                                                                aLocalName,
                                                                aValue);
        AddAttributeL(aElement, pAttribute);
        }
    return aValue;
    }

EXPORT_C const TDesC8& SenXmlUtils::AddAttributeL(CSenElement& aElement,
                                                  const TDesC8& aAttrName,
                                                  const TDesC8& aValue)
    {
    // note, the aAttrName may be a qualified name or simply localname
    // strip off the possible prefix from possible qualified name:
    TPtrC8 localName = SenXmlUtils::LocalName(aAttrName);
    return AddAttributeL(aElement, aAttrName, localName, aValue);
    }
    
EXPORT_C const TDesC8& SenXmlUtils::AddAttributeL(CSenElement& aElement,
                                                  CSenBaseAttribute* apAttribute)
    {
    CSenBaseAttribute* pOldAtt = FindAttrL( aElement, apAttribute->Name() );

    if(!pOldAtt)
        {
        // transfrer the ownership to this class:
        RPointerArray<CSenBaseAttribute>& attributes = aElement.AttributesL();
#ifdef EKA2
        attributes.AppendL(apAttribute);
#else
        User::LeaveIfError(attributes.Append(apAttribute));
#endif // EKA2
        return apAttribute->Value();
        }
    else
        {
        pOldAtt->SetValueL(apAttribute->Value());
        delete apAttribute;
        apAttribute = NULL;
        return pOldAtt->Value();
        }
    }

// END OF FILE