/*

* Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:  FolderItem either contains a list of FolderItems or contains

*                information about a feed. 

*

*/

#include "FeedsServerFolderItem.h"

#include "FolderAttributes.h"

#include "FeedAttributes.h"

#include "PackedFolder.h"

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

// CFolderItem::NewL

//

// Two-phased constructor.

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

//

CFolderItem* CFolderItem::NewL(TInt aFolderListId, CFeedsEntity* aFeedsEntity)

    {

    CFolderItem* self = new (ELeave) CFolderItem(aFolderListId, aFeedsEntity);

    CleanupStack::PushL(self);

    self->ConstructL(*aFeedsEntity);

    CleanupStack::Pop();

    return self;

    }

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

// CFolderItem::NewFolderL

//

// Two-phased constructor.

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

//

CFolderItem* CFolderItem::NewFolderL( TInt aFolderListId, const TDesC& aTitle, TInt aEntryId, TInt aStatusCode)

    {

    CFolderItem* self = new (ELeave) CFolderItem( aFolderListId );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    self->iTitle.Set(aTitle);

    self->iIsFolder = ETrue;

    self->iEntryId = aEntryId;

    // Set the timestamp to the current time as they don't apply to folders.

    self->iTimestamp.UniversalTime();

    self->iStatusCode = aStatusCode;

    return self;

    }

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

// CFolderItem::NewFeedL

//

// Two-phased constructor.

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

//

CFolderItem* CFolderItem::NewFeedL( TInt aFolderListId, const TDesC& aTitle, const TDesC& aUrl, 

        TInt aEntryId, TInt aFeedId, const TTime& aTimestamp, TInt aStatusCode, const TInt& aUnreadCount)

    {

    CFolderItem* self = new (ELeave) CFolderItem( aFolderListId );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    self->iTitle.Set(aTitle);

    self->iSourceUrl.Set(aUrl);

    self->iEntryId = aEntryId;

    self->iFeedId = aFeedId;

    self->iTimestamp = aTimestamp;

    self->iUnreadCount = aUnreadCount;

    self->iStatusCode = aStatusCode;

    return self;

    }

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

// CFolderItem::CFolderItem

// C++ default constructor can NOT contain any code, that

// might leave.    aPackedFolder is adopted 

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

//

CFolderItem::CFolderItem(TInt aFolderListId, CFeedsEntity* aFeedsEntity):

        iLeakTracker(CLeakTracker::EFolderItem), iFeedsEntity(aFeedsEntity),

		iFolderListId(aFolderListId)

    {

    }

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

// CFolderItem::CFolderItem

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CFolderItem::CFolderItem( TInt aFolderListId ):

        iLeakTracker(CLeakTracker::EFolderItem), iFolderListId(aFolderListId)

    {

    }

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

// CFolderItem::ConstructL

// Symbian 2nd phase constructor can leave.

// by this method.

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

//

void CFolderItem::ConstructL()

    {

    }

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

// CFolderItem::ConstructL

// Symbian 2nd phase constructor can leave.

// by this method.

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

//

void CFolderItem::ConstructL(const CFeedsEntity& aFeedsEntity)

    {

    TPtrC         title;

    TPtrC         url;

    TInt          feedId;

    TTime         timestamp;

    TInt          unreadCount;

    CItemMini*    miniItem = NULL;

    TPtrC         attributeValue;

    TInt 		  statusCode;

    ConstructL();    

    for(TInt i=0 ; i< aFeedsEntity.GetChildren().Count(); i++ )

        {

        CFolderItem *newItem = CFolderItem::NewL( iFolderListId, aFeedsEntity.GetChildren()[i]);    

        newItem->iParent = this;           

        iFolderItems.Append( newItem);

        }               

        iEntryId = iFeedsEntity->GetId();      

        iFeedsEntity->GetIntegerValue( EFolderAttributeStatus, statusCode);  

        iStatusCode = statusCode;

        if(iFeedsEntity->GetType()  == EFolder)

            {

            iIsFolder = ETrue;    

            iFeedsEntity->GetStringValue( EFolderAttributeTitle, title);

            iTitle.Set(title);

            // Set the timestamp to the current time as they don't apply to folders.

            iTimestamp.UniversalTime();       

            }

        else if( iFeedsEntity->GetType()  == EFeed)

            {

            iIsFolder = EFalse;

            iFeedsEntity->GetIntegerValue( EFeedAttributeFeedId, feedId);

            iFeedId = feedId;

            iFeedsEntity->GetStringValue( EFeedAttributeTitle, title);

            iTitle.Set(title);

            iFeedsEntity->GetStringValue( EFeedAttributeLink, url);

            iSourceUrl.Set(url);

            iFeedsEntity->GetTimeValue( EFeedAttributeTimestamp, iTimestamp);  

            iFeedsEntity->GetIntegerValue( EFolderAttributeUnreadCount, unreadCount);

            iUnreadCount = unreadCount; 

            }

        else if( iFeedsEntity->GetType()  == EMiniItem)

            {            

            iIsFolder = EFalse;

            miniItem = CItemMini::NewL();

            iMiniItems.Append( miniItem);   

            miniItem->iId = iEntryId = iFeedsEntity->GetId();

            iFeedsEntity->GetStringValue( EFolderAttributeMiniItemTitle, title);

            miniItem->iTitle.Set( url); 

            }    

      }

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

// CFolderItem::~CFolderItem

// Deconstructor.

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

//

EXPORT_C CFolderItem::~CFolderItem()

    {

    // Delete the items values.

    iFolderItems.ResetAndDestroy();

    iMiniItems.ResetAndDestroy();

    delete iPackedFolder;

    }

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

// CFolderItem::FolderListId

//

// Returns the folder-list-id associated with this item.

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

//

EXPORT_C TInt CFolderItem::FolderListId(void) const

    {

    return iFolderListId;

    }

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

// CFolderItem::Parent

//

// Returns the parent folder or NULL if this is the root folder.

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

//

EXPORT_C const CFolderItem* CFolderItem::Parent(void) const

    {

    return iParent;

    }

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

// CFolderItem::IsFolder

//

// Returns true if this is a folder.

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

//

EXPORT_C TBool CFolderItem::IsFolder(void) const

    {

    return iIsFolder;

    }

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

// CFolderItem::Name

//

// Returns the name of the item.

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

//

EXPORT_C const TDesC& CFolderItem::Name(void) const

    {

    return iTitle;

    }

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

// CFolderItem::SourceUrl

//

// Returns the source url of the item.

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

//

EXPORT_C const TDesC& CFolderItem::SourceUrl(void) const

    {

    if (!iIsFolder)

        {

        return iSourceUrl;

        }

    else

        {

        return KNullDesC;

        }

    }

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

// CFolderItem::Name

//

// Returns the name of the item.

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

//

EXPORT_C const TTime& CFolderItem::Timestamp(void) const

    {

    return iTimestamp;

    }

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

// CFolderItem::UnreadCount

//

// Returns the number of unread topics for this folder-item.

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

//

EXPORT_C TInt CFolderItem::UnreadCount(void) const

    {

    return iUnreadCount;

    }

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

// CFolderItem::GetFolderUnreadCount

//

// Recursively marches through folder/feed hierarchy and counts the number of

// unread according to the style in aCountType

//

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

//

TInt CFolderItem::GetFolderUnreadCount(const CFolderItem* aFolder, TCountType aCountType)

    {

    TInt folderItemCount = 0;

    TInt unreadCount = 0;

    if(NULL == aFolder)

    {

    return 0;

    }

    folderItemCount = aFolder->FolderItemCount();

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

        {

        const CFolderItem* itemInFolder = aFolder->FolderItemAt( i );

        if(itemInFolder->IsFolder())

            {

            // recurse through this folder

            unreadCount += GetFolderUnreadCount(itemInFolder,aCountType);

            }

        else

            {

            // update according to desired count

            // UnreadTopcs counts all unread articles within a feed

            // UnreadFeeds just counts the feed as unread if at least one

            // article remains unread			

            if(aCountType == ECountUnreadTopics)

                {

                unreadCount += itemInFolder->UnreadCount();

                }

            else if(aCountType == ECountUnreadFeeds)

                {

                if(itemInFolder->UnreadCount() > 0)

                    {

                    unreadCount++;

                    }

                }			

            }

        }

    return unreadCount;

    }

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

// CFolderItem::UnreadFeedCountRecursive

//

// Returns the number of unread feeds (those with > 1 undread topics) for this

// folder-item and all folders below it recursively

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

//

EXPORT_C TInt CFolderItem::UnreadFeedCountRecursive(void) const

    {

    return GetFolderUnreadCount(this, ECountUnreadFeeds);

    }

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

// CFolderItem::UnreadTopicCountRecursive

//

// Returns the number of unread topics (i.e., all articles within feed) for this

// folder-item and all folders below it recursively

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

//

EXPORT_C TInt CFolderItem::UnreadTopicCountRecursive(void) const

    {

    return GetFolderUnreadCount(this, ECountUnreadTopics);

    }

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

// CFolderItem::Id

//

// Returns the unique id for this folder-item.

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

//

EXPORT_C TInt CFolderItem::Id(void) const

    {

    return iEntryId;

    }

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

// CFolderItem::FeedId

//

// Returns the associated feed id for this folder-item.  The

// method panics if the folder-item is a folder (rather than a feed).

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

//

EXPORT_C TInt CFolderItem::FeedId(void) const

    {

    return iFeedId;

    }

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

// CFolderItem::FolderItem

//

// Returns the folder-item at the given index

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

//

EXPORT_C const CFolderItem* CFolderItem::FolderItemAt(TInt aIndex) const

    {

    if (iIsFolder && (iFolderItems.Count() > 0) && (aIndex >= 0) && (aIndex < iFolderItems.Count()))

        {

        return iFolderItems[aIndex];

        }

    else

        {

        return NULL;

        }

    }

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

// CFolderItem::Index

//

// Returns the index of the given folder-item.

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

//

EXPORT_C TInt CFolderItem::Index(const CFolderItem& aItem) const

    {

    return iFolderItems.Find(&aItem);

    }

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

// CFolderItem::FolderItemCount

//

// Returns the number of items.

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

//

EXPORT_C TInt CFolderItem::FolderItemCount(void) const

    {

    if (iIsFolder)

        {

        return iFolderItems.Count();

        }

    else

        {

        return 0;

        }

    }

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

// CFolderItem::Search

//

// Searches for a FolderItem with the given name.  If "this"

// isn't a folder it only checks whether or not it matches

// the given name.  If "this" is a folder it also checks 

// all embedded items.

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

//

EXPORT_C const CFolderItem* CFolderItem::Search(const TDesC& aName) const

    {

    // If "this" matches then return it.

    if (iTitle.CompareF(aName) == 0)

        {

        return this;

        }

    // Otherwise if this is a folder, search it's children too.

    if (IsFolder())

        {

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

            {

            const CFolderItem*  child;

            const CFolderItem*  item;

            child = FolderItemAt(i);

            if ((item = child->Search(aName)) != NULL)

                {

                return item;

                }

            }

        }

    // Otherwise no match was found.

    return NULL;

    }

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

// CFolderItem::Search

//

// Searches for a FolderItem with the given id.  If "this"

// isn't a folder it only checks whether or not it matches

// the given id.  If "this" is a folder it also checks 

// all embedded items.

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

//

EXPORT_C const CFolderItem* CFolderItem::Search(TInt aFolderItemId) const

    {

    // If "this" matches then return it.

    if (iEntryId == aFolderItemId)

        {

        return this;

        }

    // Otherwise if this is a folder, search it's children too.

    if (IsFolder())

        {

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

            {

            const CFolderItem*  child;

            const CFolderItem*  item;

            child = FolderItemAt(i);

            if ((item = child->Search(aFolderItemId)) != NULL)

                {

                return item;

                }

            }

        }

    // Otherwise no match was found.

    return NULL;

    }

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

// CFolderItem::MiniItemsCount

//

// Returns the number of mini items.

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

//

EXPORT_C TInt CFolderItem::MiniItemsCount(void) const

    {