/** @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:  Element Factory.

*

*/

// INCLUDE FILES

#include <sysutil.h>

#include <uri8.h>

#include <xmlengdomparser.h>

#include "upnpelementfactory.h"

#include "upnpcontentdirectoryglobals.h"

#include "upnpstring.h"

#include "upnpprotocolinfo.h"

#include "upnpcommonupnplits.h"

#include "upnpcdutils.h"

#include "upnpprotocolinfolocal.h"

using namespace UpnpDlnaProtocolInfo;

// ============================= LOCAL FUNCTIONS ===============================

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

// DestroyRPointerArray

// Used by TCleanupItem to destroy array

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

//

void DestroyRArray(TAny* aArray)

{

    RArray<RXmlEngDocument>* array = (RArray<RXmlEngDocument>*) aArray;

    for(TInt i = 0; i < array->Count(); i++ )

            (*array)[i].Close();

    (*array).Close();

}

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

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

// CUpnpElementFactory::~CUpnpElementFactory()

// C++ default destructor. (virtual destructor)

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

//

CUpnpElementFactory::~CUpnpElementFactory()

{

    //Close XML document

    iDocument.Close();

    iDOMImpl.Close(); 

}

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

// CUpnpElementFactory::NewL()

// Two-phased constructor

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

//

CUpnpElementFactory* CUpnpElementFactory::NewL( const TDesC& aObjectsXmlPath )

{

    CUpnpElementFactory* self = CUpnpElementFactory::NewLC( aObjectsXmlPath );

    CleanupStack::Pop( self );

    return self;

}

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

// CUpnpElementFactory::NewLC()

// Two-phased constructor

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

//

CUpnpElementFactory* CUpnpElementFactory::NewLC( const TDesC& aObjectsXmlPath )

{

    CUpnpElementFactory* self = new (ELeave) CUpnpElementFactory();

    CleanupStack::PushL( self );

    self->ConstructL( aObjectsXmlPath );

    return self;

}

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

// CUpnpElementFactory::ConstructL()

// Two-phased constructor

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

//

void CUpnpElementFactory::ConstructL(const TDesC& aObjectsXmlPath)

{

    iDOMImpl.OpenL();

    RXmlEngDOMParser parser;

    User::LeaveIfError( parser.Open(iDOMImpl) );

    CleanupClosePushL(parser);

    if ( aObjectsXmlPath == KNullDesC() )

        {

        RFs fs;

        User::LeaveIfError(fs.Connect());

        CleanupClosePushL(fs);

        TFileName path;

        User::LeaveIfError(fs.PrivatePath(path));

        TParse fp;

        fp.Set(KObjectsXmlFileName(),&path, 0);

        path = fp.FullName();

        iDocument = parser.ParseFileL( path );        

        CleanupStack::PopAndDestroy(&fs);

        }

    else

        {

        iDocument = parser.ParseFileL( aObjectsXmlPath );                

        }

    CleanupStack::PopAndDestroy(&parser);

}

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

// CUpnpElementFactory::CUpnpElementFactory()

// Default constructor

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

//

CUpnpElementFactory::CUpnpElementFactory()

{

}

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

// CUpnpElementFactory::ValidateNewObjectL()

// Function to validate a new object given by Control Point, especially 

// upnp:class element field eg. object.item.musictrack

// IMPORTANT: If objects's description is invalid due to missing elements

// it tries to repair it by adding those missing elements.

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

//

TUpnpErrorCode CUpnpElementFactory::ValidateNewObjectL( const TXmlEngElement& aNewElement, TBool aNew, TBool aLocalSharing)

{

    TInt i;    

    TPtrC8 objectType = KItem();

    RXmlEngNodeList<TXmlEngElement> elements;

    CleanupClosePushL(elements);

    aNewElement.GetChildElements( elements );

    // invalid element if the count of the objects is less than 1 (=0)

    if ( elements.Count() != 1 )

    {

        User::Leave( EInvalidArgs );

    }

    CleanupStack::PopAndDestroy(&elements);

    // try to find the new item from the xml

    TXmlEngElement object;

    UpnpDomInterface::GetElementL( aNewElement, object, KItem() );

    if ( object.IsNull() ) 

    {   

        // if it's not an item, it's a container

        UpnpDomInterface::GetElementL( aNewElement, object, KContainer() );

        if ( object.IsNull() )

        {

            // not even a container, leave!

            User::Leave ( EInvalidArgs );

        }

        objectType.Set( KContainer() );

    }

    // restriced value

    TPtrC8 restrVal = UpnpDomInterface::GetAttrValueL( object,  KRestricted );

    if ( 

    (UpnpCD::Kfalse().Compare( restrVal ) != 0) &&

    (UpnpCD::KZero().Compare( restrVal ) != 0) &&

    (UpnpCD::Ktrue().Compare( restrVal ) != 0) &&

    (UpnpCD::KOne().Compare( restrVal ) != 0)

    )

    {

        User::Leave( EBadMetadata );

    }

    // for convenience later, take now a reference to the children of the object

    RXmlEngNodeList<TXmlEngElement> children;

    CleanupClosePushL(children);

    object.GetChildElements( children );

    // an exception: we can't have <res importUri=".. element in 

    // a new object (set by control point)

    while ( children.HasNext() )

    {

        TXmlEngElement child = children.Next();

        if ( IsNotEmptyImportUriL( child ) && aNew ) 

        {

            User::Leave ( EBadMetadata );

        }

        //---- check res@duration, 7.3.22 MM DIDL-Lite res@duration Format        

        CheckDurationOfResElementL(child);

        CheckSizeOfResElementL(child);

        RXmlEngNodeList<TXmlEngElement> forbiddenChildren;

        CleanupClosePushL(forbiddenChildren);

        child.GetChildElements( forbiddenChildren );

        if ( forbiddenChildren.HasNext() 

            && child.Name() != KVendorDescriptor ) // ignore <desc></desc>

        {

            User::Leave ( EBadMetadata );

        }

        CleanupStack::PopAndDestroy(&forbiddenChildren);

        if ( child.Name() == KDate8() )

        {

            if (!UpnpCdUtils::ValidateDateL(child.Value())) 

             child.Remove();

        }

    }

    // if survived here, we have the new element of type item or container

    // let's analyze its type

    // let's inspect each of types

    // at first, collect object type descriptions from objects xml    

    // to a pointer array

    RArray<TXmlEngElement> objectDescrs;

    CleanupClosePushL( objectDescrs );

    // store class descriptor elements in this array

    ClassesL( object, objectDescrs, objectType );

    // validate each separately

    ValidatePropertiesL(object, objectDescrs);

    if(aNew)

    {

        ValidateBigImageL(object);

    }

    // for each type, check that 

    // this new object has all the required fields

    for (i=0; i<objectDescrs.Count(); i++)

    {

        // now we have to go through all the fields of the new item

        // first, for convenience take a pointer to <ps>(properties) element

        RXmlEngNodeList<TXmlEngElement> propElems;

        CleanupClosePushL(propElems);

        objectDescrs[i].GetChildElements( propElems );

        while ( propElems.HasNext() )

        {

            TXmlEngElement ps = propElems.Next(); // ps stands for properties

            if ( ps.Name() == KProperties() )

            {

                // take the properties

                RXmlEngNodeList<TXmlEngElement> properties;

                CleanupClosePushL(properties);

                ps.GetChildElements( properties );

                const TDesC8& propertyType = UpnpDomInterface::GetAttrValueL( ps, KType() );

                TBool elementFound;

                // check each property

                while ( properties.HasNext() )

                {

                    TXmlEngElement el = properties.Next();

                    // Validate element

                    if ( propertyType == KElement() )

                    {

                        elementFound = EFalse;

                        // Check if this element is requiered

                        const TDesC8& required = UpnpDomInterface::GetAttrValueL( el, KRequiredObject() );

                        TPtrC8 elementName = UpnpDomInterface::GetAttrValueL( el, KName() );

                        // If it's required then check it's existence

                        if ( required == UpnpCD::KOne() || elementName == KRes()  ||  elementName == KAlbumArtURI() )

                        {

                        if( !KRes().Compare(elementName) ||  !KAlbumArtURI().Compare(elementName))

                        {

                            elementFound = ETrue;

                        }

                            // get children once more, because this kind of list does not have any reset function

                            object.GetChildElements( children );

                            while ( children.HasNext() )

                            {

                                TXmlEngElement child = children.Next();

                                HBufC8* nameWithNs = NameWithNsLC( child );

                                if ( *nameWithNs == elementName )

                                {

                                    // local sharing

                                    if(aNew && *nameWithNs == KRes)

                                    {

                                        TUriParser8 up;

                                        TPtrC8 rv(child.Text());

                                        if(rv.Length())

                                        {

                                            User::LeaveIfError( up.Parse(child.Text()) );

                                            TPtrC8 path( up.Extract(EUriPath) );

                                            TPtrC8 scheme( up.Extract(EUriScheme) );

                                            if(aLocalSharing)

                                            { // local action

                                                if( scheme == UpnpHTTP::KSchemeFile8())

                                                {

                                                    // The path can be: /c:/....

                                                    // or /c/... - without colon.

                                                    // Both situation are correct but 

                                                    // in further operations we assume 

                                                    // there is not any colon next to the drive letter.

                                                    // Therefore, remove it if second element of path table equals ':'

                                                    if(path[2] == KColon8()[0])

                                                    { // There IS a colon next to the drive letter.

                                                        // Here is an example uri:

                                                        // file:///c:/...

                                                        // As you can see the second colon must be removed

                                                        HBufC8* uri = child.Text().AllocLC();

                                                        TPtr8 uriPtr(uri->Des());

                                                        TPtrC8 tmp(uri->Des());

                                                        TInt second = 2;

                                                        TInt colonPos = 0;

                                                        for(TInt i = 0; i < second; i++)

                                                        {

                                                            colonPos += tmp.Find(KColon8) + 1;

                                                            tmp.Set( uriPtr.Mid(colonPos) );                                                    

                                                        }

                                                        // remove the colon

                                                        uriPtr.Replace(colonPos - 1, KColon8().Length(), KNullString8);

                                                        // set TXmlEngElement value

                                                        child.SetTextL(uriPtr);

                                                        // clean up             

                                                        CleanupStack::PopAndDestroy(uri);                                               

                                                    }

                                                    // check other  restrictions

                                                    TUriParser8 up;

                                                    User::LeaveIfError( up.Parse(child.Text()) );

                                                    TPtrC8 path( up.Extract(EUriPath) );

                                                    // sharing from Z: drive is forbidden

                                                    // second character is a drive letter

                                                    if(path[1] == KForbiddenDrivez()[0] || path[1] == KForbiddenDriveZ()[0])

                                                    {

                                                        User::Leave(EArgumentValue);

                                                    }

                                                    // cannot share from private directory

                                                    if(!path.Match(KForbiddenPrivatePattern))

                                                    {

                                                        User::Leave(EArgumentValue);

                                                    }

                                                }

                                            }

                                            else

                                            { // not local action

                                                // "file" schema is forbidden here

                                                if(scheme == UpnpHTTP::KSchemeFile8())

                                                {

                                                    User::Leave(EArgumentValue);

                                                }

                                            }

                                        }

                                    }

                                    if ( elementFound ) 

                                    {

                                        // multiple values for one element!

                                        const TDesC8& multiple = UpnpDomInterface::GetAttrValueL( el, KMultiple() );

                                        // if it's not allowed for this element, leave!

                                        if ( !multiple.Length() )

                                        {

                                            User::Leave( EInvalidArgs );

                                        }

                                    }

                                    elementFound = ETrue;

                                    // mark the element required - if not res

                                    if( KRes().Compare(elementName) && KAlbumArtURI().Compare(elementName))

                                    {

                                        child.AddNewAttributeL(KRequiredAtrName,KTrueValue8);

                                    }

                                    // nested validation 

                                    RXmlEngNodeList<TXmlEngElement> nestEls;

                                    CleanupClosePushL(nestEls);

                                    el.GetChildElements(nestEls);

                                    while(nestEls.HasNext())

                                    {

                                        TXmlEngElement nestPs = nestEls.Next();

                                        // take the properties

                                        RXmlEngNodeList<TXmlEngElement> nestProperties;

                                        nestPs.GetChildElements( nestProperties );

                                        const TDesC8& nestPropertyType = UpnpDomInterface::GetAttrValueL( nestPs, KType() );

                                        // Validate attribute   

                                        if ( nestPropertyType == KAttribute() )

                                        {

                                            while(nestProperties.HasNext())

                                            {   

                                                TXmlEngElement nestEl = nestProperties.Next();

                                                //TBool nestElementFound;

                                                //nestElementFound = EFalse;

                                                const TDesC8& nestRequired = UpnpDomInterface::GetAttrValueL( nestEl, KRequiredObject() );

                                                TPtrC8 nestElementName = UpnpDomInterface::GetAttrValueL( nestEl, KName() );

                                                if ( nestRequired == UpnpCD::KOne() || nestElementName == KDlnaProfileID)

                                                {

                                                    TPtrC8 nestCurrentValue = UpnpDomInterface::GetAttrValueL( child, nestElementName );

                                                    TPtrC8 nameOfAttr;

                                                    TPtrC8 valOfAttr;

                                                    nameOfAttr.Set( nestElementName );

                                                    // Start of 'dlna:profileID' attribute case                                                 

                                                    if( nameWithNs->Des() == KAlbumArtURI && nestElementName == KDlnaProfileID) // ---------------- 1 ------------

                                                    {   

                                                        TXmlEngAttr profId = child.AttributeNodeL(KProfileID, KXmlnsDlna);

                                                        if(profId.NotNull())

                                                        {

                                                            if (profId.Value().Compare(KDefaultProfileID))

                                                            {

                                                                User::Leave( EBadMetadata );

                                                            }

                                                            // setting real name of attribute -> localName

                                                            nestElementName.Set(KProfileID); // descriptor  

                                                            nameOfAttr.Set( nestElementName ); // related TString

                                                            // generating a new value of 'dlna:profileID'

                                                            HBufC8* albumArtURIelemValue = UpnpDomInterface::GetElementValueL(child).AllocLC();

                                                            TPtr8 albumArtURIelemValuePtr( albumArtURIelemValue->Des() );                                                       

                                                            albumArtURIelemValuePtr.Trim(); // deletes leading and trailing whitespace characters                                                   

                                                            child.SetValueL(albumArtURIelemValuePtr); // sets new trimmed value to albumArtURI

                                                            CUpnpDlnaProtocolInfo* tempProtocolInfo = NULL;

                                                            TInt error = iContentDirectory->GetProtocolInfoL( albumArtURIelemValuePtr, tempProtocolInfo );

                                                            TPtrC8 tempPnParam;

                                                            if( error >=0 )

                                                            {

                                                                tempPnParam.Set( tempProtocolInfo->PnParameter() );

                                                                nestCurrentValue.Set(tempPnParam); // descriptor

                                                                valOfAttr.Set(tempPnParam); // related TString                                                         

                                                            }

                                                            else 

                                                            {

                                                                User::Leave( EBadMetadata );

                                                            }                                                       

                                                            CleanupStack::PopAndDestroy(albumArtURIelemValue);

                                                            // if albumArtURI doesn't contain profileID -> it creates one and also related namespace

                                                            // if albumArtURI contains profileID -> it modifies profileID's value

                                                            child.SetAttributeL( nameOfAttr, valOfAttr, KXmlnsDlna(), KDlnaPrefix() );

                                                            delete tempProtocolInfo;

                                                            tempProtocolInfo = NULL;    

                                                        }

                                                    } // End of 'dlna:profileID' attribute case

                                                    else                    

                                                    {

                                                        if ( !nestCurrentValue.Length() )  

                                                        {

                                                            if(nestElementName == KprotocolInfo)

                                                            {

                                                                if( ! aLocalSharing )

                                                                {

                                                                    valOfAttr.Set( KEmptyProtocolInfoVal8() );

                                                                }

                                                                else 

                                                                {

                                                                    User::Leave( EBadMetadata );

                                                                }

                                                            }                                                                                                   //------- 2 -----                                                                                    //------- 2 -----                  

                                                            else

                                                            {

                                                                valOfAttr.Set( KNullDesC8() );

                                                            }

                                                            child.AddNewAttributeL( nameOfAttr, valOfAttr );                                                            

                                                        }

                                                        else 

                                                        {

                                                            if(nestElementName == KprotocolInfo) 

                                                            {

                                                                HBufC8* protInfoValue = NULL;

                                                                TRAPD(err, protInfoValue = ValidateProtocolInfoInResL( nestCurrentValue, aLocalSharing ));

                                                                if(err)

                                                                {

                                                                    User::Leave(EBadMetadata);

                                                                }

                                                                CleanupStack::PushL( protInfoValue );

                                                                valOfAttr.Set( *protInfoValue );

                                                                child.SetAttributeL( nameOfAttr, valOfAttr );

                                                                CleanupStack::PopAndDestroy( protInfoValue );                                                           

                                                            }                                                                                                 //------- 3 -----                                                                                         //------- 3 -----

                                                        }

                                                    }                                                                                                                                                                                                                                                                                                                                                                                       

                                                    // if not main tag mark the attr is required

                                                    if( !IsMainObjectTagL(child) && nestElementName != KDlnaProfileID)

                                                    {