/** @file

* Copyright (c) 2005-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:  ContentDirectory utils

*

*/

// INCLUDE FILES

#include <uri8.h>

#include "upnpcdutils.h"

#include "upnpcontentdirectoryglobals.h"

#include "upnpdominterface.h"

#include "upnperror.h"

#include "upnpcommonupnplits.h"

#include "upnpstring.h"

#include "upnpcons.h"

#include <utf.h>

#include <xml/dom/xmlengdocument.h>

#include <e32math.h>

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CUpnpContentDirectoryDb::RemoveWhiteSpacesL

// -----------------------------------------------------------------------------

//

void UpnpCdUtils::RemoveWhiteSpacesL(TDes8& aString)

{

    for(TInt i=0; i<aString.Length(); i++)

    {

        if(    aString[i] == ' '

           ||  aString[i] == '\r'

           ||  aString[i] == '\n'

           ||  aString[i] == '\t')

        {

            aString.Replace(i,1,_L8(""));

            i--;

        }

    }

}

// -----------------------------------------------------------------------------

// UpnpCdUtils::IsWhiteString

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TBool UpnpCdUtils::IsWhiteString(const TDesC8& aString)

{

    TBool ret = ETrue;

    for(TInt i = 0; i < aString.Length(); i++)

    {

        if( !(  aString[i] == '\n' ||

                aString[i] == '\r' ||

                aString[i] == ' '  ||

                aString[i] == '\t' )  ) 

        {

            ret = EFalse;

            break;

        }

    }

    return ret;

}

// -----------------------------------------------------------------------------

// UpnpCdUtils::GetObjectElementL

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TXmlEngElement UpnpCdUtils::GetObjectElementL(RXmlEngDocument& aFragment)

{

    TXmlEngElement element;

    // try to get container

    UpnpDomInterface::GetElementL( aFragment.DocumentElement(), element, KContainer );

    if(element.IsNull())

    { // this is not a container

        // try to get an item

        UpnpDomInterface::GetElementL( aFragment.DocumentElement(), element, KItem );

        if(element.IsNull())

        { // this is neither an item - error

            User::Leave(EInvalidArgs);

        }

    }

    return element;

}

// -----------------------------------------------------------------------------

// UpnpCdUtils::HasRefIdL

// -----------------------------------------------------------------------------

//

TBool UpnpCdUtils::HasRefIdL( RXmlEngDocument& aFragment )

    {

    TXmlEngElement object = UpnpCdUtils::GetObjectElementL( aFragment );

    //reference id value

    TPtrC8 refID = UpnpDomInterface::GetAttrValueL( object, KRefID );

    return !refID.CompareF( KNullDesC8 ) ? EFalse : ETrue;

    }

// -----------------------------------------------------------------------------

// UpnpCdUtils::EncodeXmlStringL

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

HBufC8* UpnpCdUtils::EncodeXmlStringL(const TDesC8& aString)

{

    // new buffer size 

    TInt extensionSize = 0;

    for(TInt i = 0; i < aString.Length(); i++)

    {

        if(aString[i] == '&')       extensionSize += KEtAmp().Length() - 1;

        else if(aString[i] == '<')  extensionSize += KEtlt().Length() - 1;

        else if(aString[i] == '>')  extensionSize += KEtgt().Length() - 1;

        else if(aString[i] == '\"') extensionSize += KEtQuot().Length() - 1;

        else if(aString[i] == '\'') extensionSize += KEtApos().Length() - 1;

    }

    // alloc new buffer

    HBufC8* ret = HBufC8::NewLC(aString.Length() + extensionSize);

    TPtr8 retPtr(ret->Des());

    retPtr.Copy(aString);

    // replace

    for(TInt i = 0; i < retPtr.Length(); i++)

    {

        if(retPtr[i] == '&')        retPtr.Replace(i, 1, KEtAmp);

        else if(retPtr[i] == '<')   retPtr.Replace(i, 1, KEtlt);

        else if(retPtr[i] == '>')   retPtr.Replace(i, 1, KEtgt);

        else if(retPtr[i] == '\"')  retPtr.Replace(i, 1, KEtQuot);

        else if(retPtr[i] == '\'')  retPtr.Replace(i, 1, KEtApos);

    }

    // clean up

    CleanupStack::Pop(ret);

    return ret; 

}

// -----------------------------------------------------------------------------

// UpnpCdUtils::ReplaceTrueFalse

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void UpnpCdUtils::ReplaceTrueFalse(HBufC8* aBuf)

{

    TPtr8 ptr(aBuf->Des());

    TInt pos;

    // false -> 0

    pos = ptr.FindC(KFalseString8);

    if (pos != KErrNotFound)

    {

        ptr.Replace(pos, KFalseString8().Length(), KFalseValue8);

    }

    // true -> 1

    pos = ptr.FindC(KTrueString8);

    if (pos != KErrNotFound)

    {

        ptr.Replace(pos, KTrueString8().Length(), KTrueValue8);

    }

}

// -----------------------------------------------------------------------------

// UpnpCdUtils::GetElmNameWithNsL

// -----------------------------------------------------------------------------

//

HBufC8* UpnpCdUtils::GetElmNameWithNsL(TXmlEngElement aElement)

{

    TPtrC8 elmName( aElement.Name() );

    HBufC8* ret = NULL;

    if( aElement.NamespaceDeclaration().Prefix().Length() )

    {

        TPtrC8 prefix( aElement.NamespaceDeclaration().Prefix() );

        ret = HBufC8::NewL(elmName.Length() + prefix.Length() + 1);

        TPtr8 ptr(ret->Des());

        // concatenate prefix and name

        ptr.Copy(prefix);

        ptr.Append(KCol);

        ptr.Append(elmName);

    }

    else

    {

        ret = elmName.AllocL();

    }

    return ret; // the caller should delete it

}

// -----------------------------------------------------------------------------

// UpnpCdUtils::Des8ToDesL

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

HBufC* UpnpCdUtils::Des8ToDesL(const TDesC8& aString)

{

    HBufC* ret = Des8ToDesLC(aString);

    CleanupStack::Pop(ret);

    return ret;

}

// -----------------------------------------------------------------------------

// UpnpCdUtils::Des8ToDesLC

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

HBufC* UpnpCdUtils::Des8ToDesLC(const TDesC8& aString)

{    

    HBufC* ret = UpnpString::ToUnicodeL(aString);

    CleanupStack::PushL(ret);

    return ret;

}

// -----------------------------------------------------------------------------

// UpnpCdUtils::DesToDes8LC

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

HBufC8* UpnpCdUtils::DesToDes8LC(const TDesC& aString)

{

    HBufC8* ret = UpnpString::FromUnicodeL(aString);

    CleanupStack::PushL(ret);

    return ret;

}

// -----------------------------------------------------------------------------

// UpnpCdUtils::ResIdFromUriL

// -----------------------------------------------------------------------------

//

TInt64 UpnpCdUtils::ResIdFromUriL(const TDesC8& aUri)

{

    TUriParser8 up;

    User::LeaveIfError(up.Parse(aUri));

    TPtrC8 path(up.Extract(EUriPath));

    if (path.Length() == 0)

    {

    User::Leave(KErrNotFound);

    }

    if(path[0] == '/')

    {

        path.Set(path.Mid(1));

    }

    TInt index = path.Locate(TChar('/'));

    if ((index>0)&&(index != KMaxIDResLength))

    {

    	User::Leave(KErrNotFound);    

    }

    TLex8 lexer(path);

    TInt64 ret;

    User::LeaveIfError(lexer.Val(ret));

    return ret;

}

// -----------------------------------------------------------------------------

// UpnpCdUtils::ResIdFromUriL

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TPtrC8 UpnpCdUtils::ResIdFromUriDesL(const TDesC8& aUri)

{

    TUriParser8 up;

    User::LeaveIfError(up.Parse(aUri));

    TPtrC8 path(up.Extract(EUriPath));

    if (path.Length() == 0)

    {

    User::Leave(KErrNotFound);

    }

    if(path[0] == '/')

    {

        path.Set(path.Mid(1));

    }

    TInt index = path.Locate(TChar('/'));

    if (index > 0)       

    {

        path.Set(path.Left(index));        

    }

    return path;

}

// -----------------------------------------------------------------------------

// UpnpCdUtils::SetObjectIdL

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void UpnpCdUtils::SetObjectIdL(TXmlEngElement aElement, TInt aId)

{

    TXmlEngAttr idAttr = aElement.AttributeNodeL(KIdAttrName());

    TBuf8<KMaxIntegerLen> idVal;

    idVal.Num(aId);

    if(idAttr.NotNull())

    {

        idAttr.SetValueL(idVal);

    }

    else

    {

        aElement.AddNewAttributeL(KIdAttrName(), idVal);

    }

}

// -----------------------------------------------------------------------------

// UpnpCdUtils::SetObjectRefIdL

// -----------------------------------------------------------------------------

//

void UpnpCdUtils::SetObjectRefIdL(TXmlEngElement aElement, TInt aRefId)

{

    TXmlEngAttr refIdAttr = aElement.AttributeNodeL( KRefID() );

    TBuf8<KMaxIntegerLen> refIdVal;

    refIdVal.Num( aRefId );

    if( refIdAttr.NotNull() )

        {

        refIdAttr.SetValueL( refIdVal );

        }

    else

        {

        aElement.AddNewAttributeL( KRefID(), refIdVal );

        }

}

// -----------------------------------------------------------------------------

// UpnpCdUtils::SetObjectParentIdL

// -----------------------------------------------------------------------------

//

void UpnpCdUtils::SetObjectParentIdL(TXmlEngElement aElement, TInt aParentId)

{

    TXmlEngAttr parentIdAttr = aElement.AttributeNodeL( KParentID() );

    TBuf8<KMaxIntegerLen> parentIdVal;

    parentIdVal.Num( aParentId );

    if( parentIdAttr.NotNull() )

        {

        parentIdAttr.SetValueL( parentIdVal );

        }

    else

        {

        aElement.AddNewAttributeL( KParentID(), parentIdVal );

        }

}

// -----------------------------------------------------------------------------

// UpnpCdUtils::SetRestrictedFieldL

// -----------------------------------------------------------------------------

//

void UpnpCdUtils::SetRestrictedFieldL(TXmlEngElement aElement, TBool aRestrictedFlag)

{

    TXmlEngAttr restrictedField = aElement.AttributeNodeL( KRestricted() );    

    TBuf8<KMaxIntegerLen> restrictedVal;

    if( aRestrictedFlag )

        {

        restrictedVal.Copy( KTrueValue8 );

        }    

    else

        {

        restrictedVal.Copy( KFalseValue8 );

        }    

    if( restrictedField.NotNull() )

        {

        restrictedField.SetValueL( restrictedVal );

        }

    else

        {

        aElement.AddNewAttributeL( KRestricted(), restrictedVal );

        }

}

// UpnpCdUtils::SetObjectIdL

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void UpnpCdUtils::SetContainerIdL(TXmlEngElement aElement, TInt aParentId)

{

    TXmlEngAttr idAttr = aElement.AttributeNodeL(KParentID());

    TBuf8<KMaxIntegerLen> idVal;

    idVal.Num(aParentId);

    if(idAttr.NotNull())

    {

        idAttr.SetValueL(idVal);

    }

    else

    {

        aElement.AddNewAttributeL(KParentID(), idVal);

    }

}

// -----------------------------------------------------------------------------

// UpnpCdUtils::IsElementRequiredL

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TBool UpnpCdUtils::IsElementRequiredL(TXmlEngElement aElement)

{

    TBool ret = EFalse;

    TXmlEngAttr reqAttr = aElement.AttributeNodeL( KRequiredAtrName() );

    if(reqAttr.NotNull())

    { // element required

        ret = ETrue;

        reqAttr.Remove();

    }   

    return ret;

}

// -----------------------------------------------------------------------------

// UpnpCdUtils::BuildImportUriL

// (other items were commented in a header).

// -----------------------------------------------------------------------------

HBufC8* UpnpCdUtils::BuildImportUriLC(TInt aResId)

{

	// get next resId

	TBuf8<KMaxIntegerLen + KRandomRangeLength> num;

	TBuf8<KMaxIntegerLen + KRandomRangeLength> uriId;

	num.Num(aResId);

	uriId.Justify(num, KMaxIntegerLen + KRandomRangeLength, ERight, '0');

	// build uri

	HBufC8* impUri = HBufC8::NewLC(

						  KHttpTag().Length()

						+ KIpPortPlaceholder8().Length()						

						+ KSlash8().Length()						

						+ KMaxLongIntegerLen

						+ KRandomRangeLength );

	TPtr8 impUriPtr(impUri->Des());

	impUriPtr.Append(KHttpTag);

	impUriPtr.Append(KIpPortPlaceholder8);

	impUriPtr.Append(KSlash8);		

	impUriPtr.Append(uriId);

	return impUri;

}

// -----------------------------------------------------------------------------

// UpnpCdUtils::BuildImportUriL

// -----------------------------------------------------------------------------

HBufC8* UpnpCdUtils::BuildImportUriShorterLC(TInt64 aResId)

{

	// get next resId

	TBuf8<KMaxIntegerLen > num;

	TBuf8<KMaxIntegerLen > uriId;

	num.Num(aResId);

	uriId.Justify(num, KMaxIntegerLen , ERight, '0');

	// build uri

	HBufC8* impUri = HBufC8::NewLC(

						  KHttpTag().Length()

						+ KIpPortPlaceholder8().Length()						

						+ KSlash8().Length()						

						+ KMaxLongIntegerLen

						 );

	TPtr8 impUriPtr(impUri->Des());

	impUriPtr.Append(KHttpTag);

	impUriPtr.Append(KIpPortPlaceholder8);

	impUriPtr.Append(KSlash8);		

	impUriPtr.Append(uriId);

	return impUri;

}

// -----------------------------------------------------------------------------

// UpnpCdUtils::BuildContentUriL

// (other items were commented in a header).

// -----------------------------------------------------------------------------

HBufC8* UpnpCdUtils::BuildContentUriL(TInt aResId, const TDesC& aFileExten,

                                           TDesC8& aObjectId)

{

    HBufC8* number = UpnpCdUtils::RandomizeL(KRandomMax);

    CleanupStack::PushL(number);

    HBufC8* number2 = UpnpCdUtils::RandomizeL(KRandomMax);

    CleanupStack::PushL(number2);

	HBufC8* impUri = BuildImportUriShorterLC(aResId);	

    HBufC8* fileExten8 = UpnpCdUtils::DesToDes8LC(aFileExten);

	HBufC8* contUri = HBufC8::NewLC(

								impUri->Length() 

								+ number->Des().Length()

								+ number2->Des().Length()

								+ KSlash().Length()

                                + aObjectId.Length()                                

                                + fileExten8->Length());

	TPtr8 contUriPtr(contUri->Des());

	contUriPtr.Copy(*impUri);

	contUriPtr.Append(*number);	

	contUriPtr.Append(*number2);

	contUriPtr.Append(KSlash);

    contUriPtr.Append(aObjectId);    

    contUriPtr.Append(*fileExten8);

    // clean up

	CleanupStack::Pop(contUri);

    CleanupStack::PopAndDestroy(fileExten8);

	CleanupStack::PopAndDestroy(impUri);

	CleanupStack::PopAndDestroy(number2);

	CleanupStack::PopAndDestroy(number);

	return contUri;

}

// -----------------------------------------------------------------------------

// UpnpCdUtils::RandomizeL

// -----------------------------------------------------------------------------

HBufC8* UpnpCdUtils::RandomizeL(TInt aRange)

{

    TUint number = Math::Random();

    number = number % aRange;    

    HBufC8* numberDes = HBufC8::NewL(KRandomRangeLength);               

   	TBuf8<KRandomRangeLength> num;	

	num.Num(number);

    numberDes->Des().Justify(num, KRandomRangeLength, ERight, '0');    

    return numberDes;

}

// -----------------------------------------------------------------------------

// UpnpCdUtils::ValidateFilePath

// -----------------------------------------------------------------------------

void UpnpCdUtils::ValidateFilePath(TDes8& aPath)

{

    // replace

    for(TInt i = 0; i < aPath.Length(); i++)

    {

        if( aPath[i] == ':' && i!=1 || 

            aPath[i] == '<'         ||

            aPath[i] == '>'         ||

            aPath[i] == '\"'        ||

            aPath[i] == '/'         ||    

            aPath[i] == '|'         ||

            aPath[i] == '*'       ||

            aPath[i] == '?'

          )