/*

* Copyright (c) 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:   Implements CNcdNodeFactory class

*

*/

#include "ncdnodefactory.h"

#include "ncdnodeidentifier.h"

#include "ncdnodeidentifiereditor.h"

#include "ncdnodemanager.h"

#include "ncdnodedbmanager.h"

#include "ncdnodeimpl.h"

#include "ncdnodeitem.h"

#include "ncdnodefolder.h"

#include "ncdrootnode.h"

#include "ncdsearchrootnode.h"

#include "ncdsearchnodeitem.h"

#include "ncdsearchnodefolder.h"

#include "ncdnodetransparentfolder.h"

#include "ncdbundlefolder.h"

#include "ncdnodesupplier.h"

#include "ncdnodemetadataimpl.h"

#include "ncdnodeitemmetadata.h"

#include "ncdnodefoldermetadata.h"

#include "catalogsdebug.h"

#include "ncdsearchnodebundle.h"

CNcdNodeFactory* CNcdNodeFactory::NewL( CNcdNodeManager& aNodeManager )

    {

    CNcdNodeFactory* self =   

        CNcdNodeFactory::NewLC( aNodeManager );

    CleanupStack::Pop( self );

    return self;        

    }

CNcdNodeFactory* CNcdNodeFactory::NewLC( CNcdNodeManager& aNodeManager )

    {

    CNcdNodeFactory* self = 

        new( ELeave ) CNcdNodeFactory( aNodeManager );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;        

    }

CNcdNodeFactory::CNcdNodeFactory( CNcdNodeManager& aNodeManager )

: CBase(),

  iNodeManager( aNodeManager )

    {

    }

void CNcdNodeFactory::ConstructL()

    {

    // These values have to be set. 

    }

CNcdNodeFactory::~CNcdNodeFactory()

    {

    DLTRACEIN((""));

    // Delete member variables that are owned by this class object here.

    DLTRACEOUT((""));

    }        

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

// Functions to check the node types and node purposes

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

CNcdNodeFactory::TNcdNodeType CNcdNodeFactory::NodeTypeL( const TDesC8& aNodeData )

    {

    DLTRACEIN((""));

    // Check the class ids and return the correct value according to that.

    // Reads the class id from the stream

    if ( aNodeData.Length() == 0 )

        {

        DLINFO(("Node data was empty."));

        DASSERT( EFalse );

        User::Leave( KErrArgument );        

        }

    DLINFO(("Create stream from db data length: %d", aNodeData.Length()));

    RDesReadStream stream( aNodeData );                                   

    CleanupClosePushL( stream );

    // Read the class id from the stream    

    NcdNodeClassIds::TNcdNodeClassId classId =

        static_cast<NcdNodeClassIds::TNcdNodeClassId>( stream.ReadInt32L() );

    CleanupStack::PopAndDestroy( &stream );

    TNcdNodeType type( NodeTypeL( classId ) );

    DLTRACEOUT((""));

    return type;

    }

CNcdNodeFactory::TNcdNodeType CNcdNodeFactory::NodeTypeL( const CNcdNode& aNode )

    {

    DLTRACEIN((""));

    TNcdNodeType type( NodeTypeL( aNode.ClassId() ) );

    DLTRACEOUT((""));

    return type;

    }

CNcdNodeFactory::TNcdNodeType CNcdNodeFactory::NodeTypeL( NcdNodeClassIds::TNcdNodeClassId aClassId )

    {        

    // Check the class ids and return the correct value according to that.

    // Use switch case instead of if-else.

    TNcdNodeType type( ENcdNodeItem );

    switch( aClassId )

        {

        case NcdNodeClassIds::ENcdItemNodeClassId:

            DLTRACE(("Item node"));

            type = ENcdNodeItem;

            break;

        case NcdNodeClassIds::ENcdSearchItemNodeClassId:

            DLTRACE(("Search item"));

            type = ENcdNodeItem;

            break;

        case NcdNodeClassIds::ENcdFolderNodeClassId:

            DLTRACE(("Folder node"));

            type = ENcdNodeFolder;

            break;

        case NcdNodeClassIds::ENcdTransparentFolderNodeClassId:

            DLTRACE(("Transparent folder"));

            type = ENcdNodeFolder;

            break;

        case NcdNodeClassIds::ENcdSearchFolderNodeClassId:

            DLTRACE(("Search folder"));

            type = ENcdNodeFolder;

            break;

        case NcdNodeClassIds::ENcdBundleFolderNodeClassId:

            DLTRACE(("Bundle folder"));

            type = ENcdNodeFolder;

            break;

        case NcdNodeClassIds::ENcdRootNodeClassId:

            DLTRACE(("Root node"));

            type = ENcdNodeRoot;

            break;

        case NcdNodeClassIds::ENcdSearchRootNodeClassId:

            DLTRACE(("Search root node"));

            type = ENcdNodeRoot;

            break;

        case NcdNodeClassIds::ENcdSupplierNodeClassId:

            DLTRACE(("Supplier node"));

            type = ENcdNodeSupplier;

            break;

        case NcdNodeClassIds::ENcdSearchBundleNodeClassId:

            DLTRACE(("Search bundle folder"));

            type = ENcdNodeSearchBundle;

            break;

        default:

            DLERROR(("Unknown class id"));

            // For debuggin purpose

            DASSERT( EFalse );

            User::Leave( KErrUnknown );

            break;            

        }    

    return type;

    }

CNcdNodeFactory::TNcdNodePurpose CNcdNodeFactory::NodePurposeL( const CNcdNode& aNode )

    {

    DLTRACEIN((""));

    TNcdNodePurpose purpose( NodePurposeL( aNode.ClassId() ) );

    DLTRACEOUT((""));

    return purpose;    

    }

CNcdNodeFactory::TNcdNodePurpose CNcdNodeFactory::NodePurposeL( NcdNodeClassIds::TNcdNodeClassId aClassId )

    {    

    // Check the class ids and return the correct value according to that.

    // Use switch case instead of if-else.

    TNcdNodePurpose purpose( ENcdNormalNode );

    switch( aClassId )

        {

        case NcdNodeClassIds::ENcdItemNodeClassId:

            DLTRACE(("Item node"));

            purpose = ENcdNormalNode;

            break;

        case NcdNodeClassIds::ENcdSearchItemNodeClassId:

            DLTRACE(("Search item"));

            purpose = ENcdSearchNode;

            break;

        case NcdNodeClassIds::ENcdFolderNodeClassId:

            DLTRACE(("Folder node"));

            purpose = ENcdNormalNode;

            break;

        case NcdNodeClassIds::ENcdTransparentFolderNodeClassId:

            DLTRACE(("Transparent folder"));

            purpose = ENcdTransparentNode;

            break;

        case NcdNodeClassIds::ENcdSearchFolderNodeClassId:

            DLTRACE(("Search folder"));

            purpose = ENcdSearchNode;

            break;

        case NcdNodeClassIds::ENcdBundleFolderNodeClassId:

            DLTRACE(("Bundle folder"));

            purpose = ENcdBundleNode;

            break;

        case NcdNodeClassIds::ENcdRootNodeClassId:

            DLTRACE(("Root node"));

            purpose = ENcdNormalNode;

            break;

        case NcdNodeClassIds::ENcdSearchRootNodeClassId:

            DLTRACE(("Search root node"));

            purpose = ENcdSearchNode;

            break;

        case NcdNodeClassIds::ENcdSupplierNodeClassId:

            DLTRACE(("Supplier node"));

            purpose = ENcdNormalNode;

            break;

        case NcdNodeClassIds::ENcdSearchBundleNodeClassId:

            DLTRACE(("Search bundle folder"));

            purpose = ENcdSearchNode;

            break;

        default:

            DLERROR(("Unknown class id"));

            // For debuggin purpose

            DASSERT( EFalse );

            User::Leave( KErrUnknown );

            break;            

        }

    return purpose;

    }

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

// Functions to find out the node class id

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

NcdNodeClassIds::TNcdNodeClassId CNcdNodeFactory::NodeClassIdL( CNcdNodeFactory::TNcdNodeType aNodeType,

                                                               CNcdNodeFactory::TNcdNodePurpose aNodePurpose )

    {

    NcdNodeClassIds::TNcdNodeClassId classId( NcdNodeClassIds::ENcdNullObjectClassId );

    // Check if the node is item, folder or root    

    switch( aNodeType )

        {

        case ENcdNodeItem:

            {

            // The node is item.

            // Check what kind of item.

            switch( aNodePurpose )

                {

                case ENcdNormalNode:

                    DLTRACE(("Normal item node class id"));

                    classId = NcdNodeClassIds::ENcdItemNodeClassId;

                    break;

                case ENcdChildOfTransparentNode:

                    DLTRACE(("Transparent child item class id"));

                    classId = NcdNodeClassIds::ENcdItemNodeClassId;

                    break;

                case ENcdSearchNode:

                    DLTRACE(("Search item class id"));

                    classId = NcdNodeClassIds::ENcdSearchItemNodeClassId;

                    break;

                default:

                    DLERROR(("Unknown node item purpose"));

                    // For debuggin purpose

                    DASSERT( EFalse );

                    User::Leave( KErrUnknown );

                    break;            

                }            

            }

            break;

        case ENcdNodeFolder:

            {

            // The node is folder.

            // Check what kind of folder.

            switch( aNodePurpose )

                {

                case ENcdNormalNode:

                    DLTRACE(("Normal folder class id"));

                    classId = NcdNodeClassIds::ENcdFolderNodeClassId;

                    break;

                case ENcdChildOfTransparentNode:

                    DLTRACE(("Transparent child folder class id"));

                    classId = NcdNodeClassIds::ENcdFolderNodeClassId;

                    break;

                case ENcdSearchNode:

                    DLTRACE(("Search folder class id"));

                    classId = NcdNodeClassIds::ENcdSearchFolderNodeClassId;

                    break;

                case ENcdBundleNode:

                    DLTRACE(("Bundle folder class id"));

                    classId = NcdNodeClassIds::ENcdBundleFolderNodeClassId;

                    break;

                case ENcdTransparentNode:

                    DLTRACE(("Transparent folder class id"));

                    classId = NcdNodeClassIds::ENcdTransparentFolderNodeClassId;

                    break;

                default:

                    DLERROR(("Unknown node folder purpose"));

                    // For debuggin purpose

                    DASSERT( EFalse );

                    User::Leave( KErrUnknown );

                    break;            

                }            

            }

            break;

        case ENcdNodeRoot:

            {

            switch( aNodePurpose )

                {

                case ENcdNormalNode:

                    DLTRACE(("Root class id"));

                    classId = NcdNodeClassIds::ENcdRootNodeClassId;

                    break;

                case ENcdSearchNode:

                    DLTRACE(("Search root as normal folder class id"));

                    // Notice that the search root is actually normal search folder.

                    // Should this be changed when the id functions properly?

                    classId = NcdNodeClassIds::ENcdSearchRootNodeClassId;

                    break;

                default:

                    DLERROR(("Unknown node root purpose"));

                    // For debuggin purpose

                    DASSERT( EFalse );

                    User::Leave( KErrUnknown );

                    break;                           

                }

            }

            break;

        case ENcdNodeSupplier:

            {

            // The supplier class id will always be the same.

            classId = NcdNodeClassIds::ENcdSupplierNodeClassId;            

            }

        break;

        case ENcdNodeSearchBundle:

            {

            // The search bundle class id will always be the same.

            classId = NcdNodeClassIds::ENcdSearchBundleNodeClassId;            

            }

        break;

        default:

            DLERROR(("Unknown node type"));

            // For debuggin purpose

            DASSERT( EFalse );

            User::Leave( KErrUnknown );

            break;            

        };

    return classId;

    }

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

// Functions to create node objects

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

CNcdNodeItem* CNcdNodeFactory::CreateNodeItemL( const CNcdNodeIdentifier& aParentIdentifier,

                                                const CNcdNodeIdentifier& aMetaDataIdentifier, 

                                                NcdNodeClassIds::TNcdNodeClassId aClassId ) const

    {

    DLTRACEIN((""));

    CNcdNodeItem* item( CreateNodeItemLC( aParentIdentifier, 

                                          aMetaDataIdentifier, 

                                          aClassId ) );

    if ( item != NULL )

        {

        CleanupStack::Pop( item );

        }

    DLTRACEOUT((""));

    return item;

    }

CNcdNodeItem* CNcdNodeFactory::CreateNodeItemLC( const CNcdNodeIdentifier& aParentIdentifier,

                                                 const CNcdNodeIdentifier& aMetaDataIdentifier, 

                                                 NcdNodeClassIds::TNcdNodeClassId aClassId ) const

    {

    DLTRACEIN((""));

    // Creates the node, 

    // but does not internalize its data from anywhere.

    CNcdNodeIdentifier* identifier = 

        NcdNodeIdentifierEditor::CreateNodeIdentifierLC( aParentIdentifier, aMetaDataIdentifier );

    // First check if the node can be created as an item.

    CNcdNodeItem* item( CreateNodeItemLC( *identifier, 

                                          aClassId ) );

    CleanupStack::PopAndDestroy( identifier );

    DLTRACEOUT((""));

    return item;    

    }

CNcdNodeItem* CNcdNodeFactory::CreateNodeItemL( const CNcdNodeIdentifier& aNodeIdentifier, 

                                                NcdNodeClassIds::TNcdNodeClassId aClassId ) const

    {

    DLTRACEIN((""));

    CNcdNodeItem* item( CreateNodeItemLC( aNodeIdentifier, 

                                          aClassId) );

    if ( item != NULL )

        {

        CleanupStack::Pop( item );

        }

    DLTRACEOUT((""));

    return item;

    }

CNcdNodeItem* CNcdNodeFactory::CreateNodeItemLC( const CNcdNodeIdentifier& aNodeIdentifier, 

                                                 NcdNodeClassIds::TNcdNodeClassId aClassId ) const

    {

    DLTRACEIN((""));

    // Creates the node, 

    // but does not internalize its data from anywhere.

    CNcdNodeItem* item( NULL );

    // Create object according to the class type

    switch( aClassId )

        {

        case NcdNodeClassIds::ENcdItemNodeClassId:

            DLINFO(("Item node"));

            item = CNcdNodeItem::NewLC( NodeManager(), aNodeIdentifier );

            break;

        case NcdNodeClassIds::ENcdSearchItemNodeClassId:

            DLINFO(("Search item node"));

            item = CNcdSearchNodeItem::NewLC( NodeManager(), aNodeIdentifier );

            break;

        default:

            DLERROR(("Unknown node item class id. Return NULL"));

            // Do not insert assert here because CreateNodeL(C) function uses this

            // function among other create functions to create nodes.

            item = NULL;

            break;            

        }

    DLTRACEOUT((""));

    return item;    

    }