/** @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));

        // Load dll file

        TFileName objectsXmlFileName( KObjectsXmlFileName() );

        TFileName dllName;

        Dll::FileName( dllName );

        TBuf<2> drive = dllName.Left( 2 ); // Drive letter followed by ':' 

        objectsXmlFileName.Insert( 0, drive );

        TParse fp;

        fp.Set(objectsXmlFileName,&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::CheckRestrictedValue()

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

//

TBool CUpnpElementFactory::CheckRestrictedValue (TPtrC8& restrVal)

    {

    TBool retVal = EFalse;

    if ( 

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

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

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

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

    )

        {

        retVal = ETrue;

        }

    return retVal;

    }

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

// 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 (CheckRestrictedValue(restrVal))

        {

        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(EFalse);

                // check each property

                while ( properties.HasNext() )

                {

                    TXmlEngElement el = properties.Next();

                    elementFound = ValidateElementL (object, propertyType, el, elementFound, aNew, aLocalSharing);

                    // Validate attribute   

                    if ( propertyType == KAttribute() )

                    {

                        elementFound = EFalse;

                        ValidateAttributeL(el, object);

                    }

                }

                CleanupStack::PopAndDestroy(&properties);

            }

        }

        CleanupStack::PopAndDestroy(&propElems);

    }

    CleanupStack::PopAndDestroy(); //objectDescrs.Close();

    CleanupStack::PopAndDestroy(&children);

    // now the object 

    // * has the all required fields (if some were missing, they are added)

    // * had a proper xml structure (_not_ using UpnpDomInterface:: functions that do not care)

    // * has for sure a mostly proper object structure 

    return EUndefined;

}

TBool CUpnpElementFactory::ValidateElementL (TXmlEngElement aObject, 

        const TDesC8& aPropertyType, TXmlEngElement aEl, TBool aElementFound, TBool aNew,

        TBool aLocalSharing)

    {

        TBool elementFound = aElementFound;

        RXmlEngNodeList<TXmlEngElement> children;

        // Validate element

        if ( aPropertyType == KElement() )

        {

            elementFound = EFalse;

            // Check if this element is requiered

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

            TPtrC8 elementName = UpnpDomInterface::GetAttrValueL( aEl, 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

                aObject.GetChildElements( children );

                elementFound = HandleChildrenL (children, aNew, aLocalSharing, elementFound, aEl);

                // If not found, add it

                if ( !elementFound )

                {

                    User::Leave(EBadMetadata);

                }

            } 

        }

        return elementFound;

    }

TBool CUpnpElementFactory::HandleChildrenL (RXmlEngNodeList<TXmlEngElement> aChildren, TBool aNew, TBool aLocalSharing,

        TBool aElementFound, TXmlEngElement aEl)

    {

    TBool elementFound = aElementFound;

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

    while ( aChildren.HasNext() )

    {

        TXmlEngElement child = aChildren.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( aEl, 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);

            aEl.GetChildElements(nestEls);

            CheckNestedElementsL(nestEls, child, aLocalSharing);

            CleanupStack::PopAndDestroy(&nestEls);

        }

        CleanupStack::PopAndDestroy( nameWithNs );

    }

    return elementFound;

}

void CUpnpElementFactory::CheckNestedElementsL(RXmlEngNodeList<TXmlEngElement> aNestEls, TXmlEngElement aChild,

        TBool aLocalSharing)

{

    HBufC8* nameWithNs = NameWithNsLC( aChild );