/** @file
* Copyright (c) 2006-2009 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:  UPnP Device Description Store
*
*/


#include <upnpdominterface.h>

#include <upnpdevicedescriptionstore.h>
#include <upnpcommonupnplits.h>
#include "upnpfileutils.h"
#include "upnpicon.h"
#include "upnpdevice.h"
#include "upnpcontenthandlerscontroller.h"

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

// ---------------------------------------------------------------------------
// CUpnpDeviceDescriptionStore::NewL()
// Two phased constructor
// ---------------------------------------------------------------------------
//
EXPORT_C CUpnpDeviceDescriptionStore *CUpnpDeviceDescriptionStore::NewL(
    const TDesC& aFilename )
    {
    CUpnpDeviceDescriptionStore* self = CUpnpDeviceDescriptionStore::NewLC( aFilename );    
    CleanupStack::Pop();
    return self;
    }

// ---------------------------------------------------------------------------
// CUpnpDeviceDescriptionStore::NewLC()
// Two phased constructor, leaves the object onto the CleanupStack
// ---------------------------------------------------------------------------
//
EXPORT_C CUpnpDeviceDescriptionStore* CUpnpDeviceDescriptionStore::NewLC(
    const TDesC& aFilename )
    {
    CUpnpDeviceDescriptionStore* self = new (ELeave) CUpnpDeviceDescriptionStore();
    CleanupStack::PushL( self );
    self->ConstructL( aFilename );
    return self;
    }

// ---------------------------------------------------------------------------
// CUpnpDeviceDescriptionStore::~CUpnpDeviceDescriptionStore()
// Destructor of CUpnpDeviceDescriptionStore class
// ---------------------------------------------------------------------------
//
CUpnpDeviceDescriptionStore::~CUpnpDeviceDescriptionStore()
    {
    iFileName.Close();
    iDescription.Close();
    iParser.Close();
    iDOMImpl.Close();
    }

// ---------------------------------------------------------------------------
// CUpnpDeviceDescriptionStore::DescriptionFile()
// ---------------------------------------------------------------------------
//
EXPORT_C const TDesC& CUpnpDeviceDescriptionStore::DescriptionFile()
    {
    return iFileName;
    }

// ---------------------------------------------------------------------------
// CUpnpDeviceDescriptionStore::SetPropertyL()
// Sets some property value in an emmbedded device.
// ---------------------------------------------------------------------------
//
EXPORT_C void CUpnpDeviceDescriptionStore::SetPropertyL( const TDesC8& aName,
    const TDesC8& aValue, const TDesC8& aUuid )
    {
    TXmlEngElement root = iDescription.DocumentElement();
    TXmlEngElement local;
    TXmlEngElement property;
    RArray<TXmlEngElement> elementList;

    TRAPD( error, UpnpDomInterface::GetElementListL( root, elementList, KUdn ) );

    for ( TInt i( 0); i < elementList.Count() ; i++ )
        {
        if ( !elementList[ i ].Value().Compare( aUuid ) )
            {
            elementList.Close();

            TRAP( error, UpnpDomInterface::GetElementListL( root,
                elementList, aName ) );

            if ( elementList.Count() && i < elementList.Count() )
                {
                property = elementList[ i ];
                elementList.Close();
                if ( !error )
                    {
                    property.SetValueL( aValue );
                    return;
                    }
                }
            else
                {
                User::Leave( KErrNotFound );
                }
            }
        }

    elementList.Close();
    User::Leave( KErrNotFound );
    }

// -----------------------------------------------------------------------------
// CUpnpDeviceDescriptionStore::RemoveTagL
// -----------------------------------------------------------------------------
//
EXPORT_C void CUpnpDeviceDescriptionStore::RemoveTagL( const TDesC8& aTagName )
    {
    TXmlEngElement root = iDescription.DocumentElement();
    TXmlEngElement element;
    TBool elementFound = EFalse;

    elementFound = UpnpDomInterface::GetElementL( root, element, aTagName );
    if ( elementFound )
        {
        UpnpDomInterface::DeleteElement( element );
        }
    }

// -----------------------------------------------------------------------------
// CUpnpDeviceDescriptionStore::AddTagL
// -----------------------------------------------------------------------------
//
EXPORT_C TXmlEngElement CUpnpDeviceDescriptionStore::AddTagL( const TDesC8& aTagName )
    {
    TXmlEngElement root = iDescription.DocumentElement();
    TXmlEngElement level1;
    TXmlEngElement level2;
    TBool elementFound = EFalse;

    elementFound = UpnpDomInterface::GetElementL( root, level1, KDevice );
    if ( elementFound )
        {
        elementFound = UpnpDomInterface::GetElementL( level1, level2,
            aTagName );
        if ( !elementFound )
            {
            level2 = level1.AddNewElementL( aTagName );
            }
        }
    return level2;
    }

// ---------------------------------------------------------------------------
// CUpnpDeviceDescriptionStore::AddIconL()
// ---------------------------------------------------------------------------
//
EXPORT_C void CUpnpDeviceDescriptionStore::AddIconL( const CUpnpIcon& aIcon )
    {
    TXmlEngElement root = iDescription.DocumentElement();
    TXmlEngElement propertyref;
    TXmlEngElement property;
    TXmlEngElement propertyiconlist;
    TXmlEngElement url;
    RArray<TXmlEngElement> IconList;

    TRAPD( error, UpnpDomInterface::GetElementL( root, property, KDevice ) );
    if ( !error && property.NotNull() )
        {
        TRAPD( error, UpnpDomInterface::GetElementL( property,
            propertyiconlist, KIconList ) );
        if ( !error && propertyiconlist.NotNull() )
            {
            TRAPD( error, UpnpDomInterface::GetElementListL(
                propertyiconlist, IconList, KIcon ) );
            if ( !error && IconList.Count() != 0 )
                {
                AddIconElementL( propertyiconlist, aIcon.MimeType(),
                    aIcon.WidthTPtrC8(), aIcon.HeightTPtrC8(),
                    aIcon.DepthTPtrC8(), aIcon.Url() );
                }
            User::LeaveIfError( error );
            }
        else
            {
            propertyref = property.AddNewElementL( KIconList );
            AddIconElementL( propertyref, aIcon.MimeType(),
                aIcon.WidthTPtrC8(), aIcon.HeightTPtrC8(),
                aIcon.DepthTPtrC8(), aIcon.Url() );
            }
        User::LeaveIfError( error );
        }
    User::LeaveIfError( error );

    IconList.Close();
    }

// ---------------------------------------------------------------------------
// CUpnpDeviceDescriptionStore::UpdateIconL()
// ---------------------------------------------------------------------------
//
EXPORT_C void CUpnpDeviceDescriptionStore::UpdateIconL( const CUpnpIcon& aIcon )
    {
    TXmlEngElement propertyiconlist = GetIconlistElementL();
    TXmlEngElement url;
    RArray<TXmlEngElement> IconList;

    TRAPD( error, UpnpDomInterface::GetElementListL( propertyiconlist,
        IconList, KIcon ) );
    if ( !error && IconList.Count() != 0 )
        {
        for ( TInt i=0; i<IconList.Count(); i++ )
            {
            TRAPD( error, UpnpDomInterface::GetElementL( IconList[ i ], url,
                KUrl ) );
            if ( !error && url.NotNull() )
                {
                if ( !url.Value().Compare( aIcon.Url() ) )
                    {
                    IconList[i].Remove();
                    AddIconElementL( propertyiconlist, aIcon.MimeType(),
                        aIcon.WidthTPtrC8(), aIcon.HeightTPtrC8(),
                        aIcon.DepthTPtrC8(), aIcon.Url() );
                    }
                }
            }
        User::LeaveIfError( error );
        }
    IconList.Close();
    }

// ---------------------------------------------------------------------------
// CUpnpDeviceDescriptionStore::RemoveIconL()
// ---------------------------------------------------------------------------
//
EXPORT_C void CUpnpDeviceDescriptionStore::RemoveIconL( const TDesC8& aUrl )
    {
    TXmlEngElement propertyiconlist = GetIconlistElementL();
    TXmlEngElement url;
    RArray<TXmlEngElement> IconList;

    TRAPD( error, UpnpDomInterface::GetElementListL( propertyiconlist,
        IconList, KIcon ) );
    if ( !error && IconList.Count()!=0 )
        {
        for ( TInt i=0; i<IconList.Count(); i++ )
            {
            TRAPD( error, UpnpDomInterface::GetElementL( IconList[ i ], url,
                KUrl ) );
            if ( !error && url.NotNull() )
                {
                if ( !url.Value().Compare( aUrl ) )
                    {
                    if ( IconList.Count() == 1 )
                        {
                        propertyiconlist.Remove();
                        }
                    else
                        {
                        IconList[i].Remove();
                        }
                    }
                }
            }
        User::LeaveIfError( error );
        }
    IconList.Close();
    }

// ---------------------------------------------------------------------------
// CUpnpDeviceDescriptionStore::RemoveIconsL()
// ---------------------------------------------------------------------------
//  
EXPORT_C void CUpnpDeviceDescriptionStore::RemoveIconsL()
    {
    TXmlEngElement propertyiconlist = GetIconlistElementL();
    if ( propertyiconlist.NotNull() )
        {
        propertyiconlist.Remove();
        }
    }

// ---------------------------------------------------------------------------
// CUpnpDeviceDescriptionStore::GetIconlistElementL()
// Gets iconlist element
// ---------------------------------------------------------------------------
//    
EXPORT_C TXmlEngElement CUpnpDeviceDescriptionStore::GetIconlistElementL()
    {
    TXmlEngElement root = iDescription.DocumentElement();
    TXmlEngElement property;
    TXmlEngElement propertyiconlist;

    TRAPD( error, UpnpDomInterface::GetElementL( root, property, KDevice ) );
    if ( !error && property.NotNull() )
        {
        TRAPD( error, UpnpDomInterface::GetElementL( property,
            propertyiconlist, KIconList ) );
        if ( !error && propertyiconlist.NotNull() )
            {
            return propertyiconlist;
            }
        User::LeaveIfError( error );
        }
    User::LeaveIfError( error );

    return NULL;
    }

// ---------------------------------------------------------------------------
// CUpnpDeviceDescriptionStore::Property()
// Gets some property value from an embedded device.
// ---------------------------------------------------------------------------
//
EXPORT_C TPtrC8 CUpnpDeviceDescriptionStore::Property( const TDesC8& aName,
    const TDesC8& aUuid )
    {
    TXmlEngElement root = iDescription.DocumentElement();
    TXmlEngElement local;
    TXmlEngElement property;
    RArray<TXmlEngElement> elementList;
    TPtrC8 urn = KNullDesC8();

    TRAPD( error, UpnpDomInterface::GetElementListL( root, elementList, KUdn ) );

    for ( TInt i( 0); i < elementList.Count() ; i++ )
        {
        if ( !elementList[ i ].Value().Compare( aUuid ) )
            {
            elementList.Close();

            TRAP( error, UpnpDomInterface::GetElementListL( root,
                elementList, aName ) );

            if ( elementList.Count() )
                {
                property = elementList[ i ];

                if ( !error && property.Value().Length() )
                    {
                    urn.Set( property.Value() );
                    break;
                    }
                }
            }
        }
    elementList.Close();
    return urn;
    }

// ---------------------------------------------------------------------------
// CUpnpDeviceDescriptionStore::SetPropertyL()
// Sets some property value in a root device.
// ---------------------------------------------------------------------------
//   
EXPORT_C void CUpnpDeviceDescriptionStore::SetPropertyL( const TDesC8& aName,
    const TDesC8& aValue )
    {
    TXmlEngElement root = iDescription.DocumentElement();
    TXmlEngElement level1;

    UpnpDomInterface::GetElementL( root, level1, aName );

    if ( level1.NotNull() )
        {
        level1.SetValueL( aValue );
        }

    else if ( !level1.NotNull() )
        {
        level1 = AddTagL( aName );

        if ( level1.NotNull() )
            {
            level1.SetValueL( aValue );
            }
        }
    }

// ---------------------------------------------------------------------------
// CUpnpDeviceDescriptionStore::Property()
// Gets some property value from a root device.
// ---------------------------------------------------------------------------
//
EXPORT_C TPtrC8 CUpnpDeviceDescriptionStore::Property( const TDesC8& aName )
    {
    TXmlEngElement root = iDescription.DocumentElement();
    TXmlEngElement property;
    TPtrC8 urn = KNullDesC8();

    TRAPD( error, UpnpDomInterface::GetElementL( root, property, aName ) );

    if ( !error && property.NotNull() && property.Value().Length() )
        {
        urn.Set( property.Value() );
        }

    return urn;
    }

// ---------------------------------------------------------------------------
// CUpnpDeviceDescriptionStore::SaveL()
// Saves device description file path
// ---------------------------------------------------------------------------
//
EXPORT_C void CUpnpDeviceDescriptionStore::SaveL()
    {
    if ( UpnpFileUtil::CheckDiskSpaceShortL( EDriveC, KMinSpaceToWriteDescription ) )
        {
        User::Leave( KErrDiskFull );
        }
    iDescription.SaveL( iFileName );
    }

// -----------------------------------------------------------------------------
// CUpnpDeviceDescriptionStore::IconListL
// -----------------------------------------------------------------------------
//
EXPORT_C RPointerArray< CUpnpIcon > CUpnpDeviceDescriptionStore::IconListL()
    {
    RPointerArray< CUpnpIcon > iconList;

    HBufC8* descr = UpnpFileUtil::ReadFileL( iFileName );
    CleanupStack::PushL( descr );
    
    CUpnpContentHandlersController* controller = CUpnpContentHandlersController::NewLC();
    CUpnpDevice* device = controller->ParseDeviceL( *descr );
    CleanupStack::PopAndDestroy( controller );
    CleanupStack::PushL( device );

    for ( TInt i = 0; i < device->Icons().Count(); i++ )
        {
        iconList.AppendL( device->Icons()[ i ] );
        }
    device->Icons().Reset();
    
    CleanupStack::PopAndDestroy( device );
    CleanupStack::PopAndDestroy( descr );
    
    return iconList;
    }

// ---------------------------------------------------------------------------
// CUpnpDeviceDescriptionStore::CUpnpDeviceDescriptionStore()
// Default C++ constructor
// ---------------------------------------------------------------------------
//
CUpnpDeviceDescriptionStore::CUpnpDeviceDescriptionStore()
    {
    }

// ---------------------------------------------------------------------------
// CUpnpDeviceDescriptionStore::ConstructL()
// 2nd phase constructor
// ---------------------------------------------------------------------------
//
void CUpnpDeviceDescriptionStore::ConstructL( const TDesC& aFileName )
    {
    iFileName.CreateL( aFileName );

    HBufC8* descr = UpnpFileUtil::ReadFileL( aFileName );
    CleanupStack::PushL( descr );

    iDOMImpl.OpenL();
    User::LeaveIfError( iParser.Open( iDOMImpl ) );
    iDescription = iParser.ParseL( *descr );
    CleanupStack::PopAndDestroy( descr );
    }

// ---------------------------------------------------------------------------
// CUpnpDeviceDescriptionStore::AddIconElementL()
// Adds icon element
// ---------------------------------------------------------------------------
//    
void CUpnpDeviceDescriptionStore::AddIconElementL(
    TXmlEngElement& aPropertyIcon, const TDesC8& aMimeType,
    const TDesC8& aWidth, const TDesC8& aHeight, const TDesC8& aDepth,
    const TDesC8& aUrl )
    {
    TXmlEngElement propertyIcon = aPropertyIcon.AddNewElementL( KIcon );
    TXmlEngElement propertyref = propertyIcon.AddNewElementL( KMimeType );
    propertyref.SetTextL( aMimeType );
    propertyref = propertyIcon.AddNewElementL( KWidth );
    propertyref.SetTextL( aWidth );
    propertyref = propertyIcon.AddNewElementL( KHeight );
    propertyref.SetTextL( aHeight );
    propertyref = propertyIcon.AddNewElementL( KDepth );
    propertyref.SetTextL( aDepth );
    propertyref = propertyIcon.AddNewElementL( KUrl );
    propertyref.SetTextL( aUrl );
    }

//  End of File