/*

* Copyright (c) 2008 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:  The client side connection to the FeedsSever.

 *

*/

#include "PackedAttributes.h"

#include <folderattributes.h>

#include "Packed.h"

#include "PackedFeed.h"

#include "PackedFolder.h"

// Constant definitions

_LIT(KNew, "new");

_LIT(KRead, "read");

_LIT(KUnread, "unread");

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

// CFeedsEntity::ChangeValueL

//

// Changes attribute/Property values based on passed Map

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

//

EXPORT_C TInt CFeedsEntity::ChangeValueL(const CFeedsMap& aNewValues)

    {

    return iFeedInterface->SetAttributeL(*this, aNewValues);

    } 

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

// CFeedsEntity::GetStringValue

//

// Returns String value based on passed attribute.

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

//

EXPORT_C TInt CFeedsEntity::GetStringValue(TUint anAttribute, TPtrC& aValue) const

    {

    return iAttrProp->GetStringAttribute(anAttribute, aValue);

    }

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

// CFeedsEntity::GetIntegerValue

//

// Initialises aValue with integer value of passed anAttribute.

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

//

EXPORT_C TInt CFeedsEntity::GetIntegerValue(TUint anAttribute, TInt& aValue) const

    {

    if(EFeedAttributeFeedId == anAttribute)

        {

        aValue = iFeedId;

        return KErrNone;    

        }

    else

        return iAttrProp->GetIntegerAttribute(anAttribute, aValue);

    }

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

// CFeedsEntity::GetTimeValue

//

// Initialises aValue with time value of passed anAttribute.

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

//

EXPORT_C TInt CFeedsEntity::GetTimeValue(TUint anAttribute, TTime& aValue) const

    {

    return iAttrProp->GetTimeAttribute(anAttribute, aValue);

    }

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

// CFeedsEntity::NewL

//

// Two-phased constructor.

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

//

CFeedsEntity* CFeedsEntity::NewL(RFeedsInterface* aFeedsInterface)

    {

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

    CleanupStack::PushL (self);

    self->ConstructL ();

    self->SetFeedInterface (aFeedsInterface);

    CleanupStack::Pop ();

    return self;

    }

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

// CFeedsEntity::NewL

//

// Two-phased constructor.

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

//

CFeedsEntity* CFeedsEntity::NewL(CPackedFolder* aPackedFolder,

        RFeedsInterface* aFeedsInterface)

    {

    CFeedsEntity* self = new (ELeave) CFeedsEntity(aPackedFolder);

    CleanupStack::PushL (self);

    self->SetFeedInterface (aFeedsInterface);

    self->ConstructL (*aPackedFolder);

    CleanupStack::Pop ();

    return self;

    }

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

// CFeedsEntity::NewL

//

// Two-phased constructor.

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

//

CFeedsEntity* CFeedsEntity::NewL(CPackedFeed* aPackedFeed,

        RFeedsInterface* aFeedsInterface)

    {

    CFeedsEntity* self = new (ELeave) CFeedsEntity(aPackedFeed);

    CleanupStack::PushL (self);

    self->SetFeedInterface (aFeedsInterface);

    self->ConstructL (*aPackedFeed);

    CleanupStack::Pop ();

    return self;

    }

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

// CFeedsEntity::NewFolderL

//

// Two-phased constructor.

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

//

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

    {

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

    CleanupStack::PushL (self);

    self->ConstructL ();

    CleanupStack::Pop ();

    self->iId = aEntryId;

    self->iType = EFolder;

    self->iAttrProp->SetStringAttribute (EFolderAttributeTitle, aTitle);

    self->iAttrProp->SetIntegerAttribute(EFolderAttributeStatus,aStatusCode);

    return self;

    }

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

// CFeedsEntity::NewFeedL

//

// Two-phased constructor.

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

//

CFeedsEntity* CFeedsEntity::NewFeedL( const TDesC& aTitle, const TDesC& aUrl,

        TInt aEntryId, TInt aFeedId, const TTime& aTimestamp, TInt aStatusCode, TInt aFreq,

        const TInt& aUnreadCount)

    {

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

    CleanupStack::PushL (self);

    self->ConstructL ();

    CleanupStack::Pop ();

    self->iId = aEntryId;

    self->iType = EFeed;

    self->iAttrProp->SetStringAttribute (EFeedAttributeTitle, aTitle);

    self->iAttrProp->SetStringAttribute (EFeedAttributeLink, aUrl);

    self->iAttrProp->SetTimeAttribute (EFeedAttributeTimestamp, aTimestamp);

    self->iAttrProp->SetIntegerAttribute (EFeedAttributeAutoUpdateFreq, aFreq);

    self->iAttrProp->SetIntegerAttribute (EFolderAttributeUnreadCount,

    		aUnreadCount);

    self->iFeedId = aFeedId;

    self->iAttrProp->SetIntegerAttribute(EFolderAttributeStatus,aStatusCode);

    return self;

    }

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

// CFeedsEntity::NewMiniItemL

//

// Two-phased constructor.

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

//

CFeedsEntity* CFeedsEntity::NewMiniItemL()

    {

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

    CleanupStack::PushL (self);

    self->ConstructL ();

    CleanupStack::Pop ();

    self->iType = EMiniItem;

    return self;

    }

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

// CFeedsEntity::CFeedsEntity

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

// might leave.    aPackedFolder is adopted 

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

//

CFeedsEntity::CFeedsEntity(CPackedFolder* aPackedFolder) :

    iPacked((CPacked*)aPackedFolder)

    {

    }

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

// CFeedsEntity::CFeedsEntity

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

// might leave.    aPackedFolder is adopted 

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

//

CFeedsEntity::CFeedsEntity(CPackedFeed* aPackedFeed) :

    iPacked((CPacked*)aPackedFeed)

    {

    }

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

// CFeedsEntity::CFeedsEntity

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

// might leave.

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

//

CFeedsEntity::CFeedsEntity()

    {

    }

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

// CFeedsEntity::ConstructL

// Symbian 2nd phase constructor can leave.

// by this method.

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

//

void CFeedsEntity::ConstructL()

    {

    iAttrProp = CFeedsMap::NewL ();

    }

CFeedsEntity::~CFeedsEntity()

    {

    delete iAttrProp;

    iAttrProp = NULL;

    iChildren.ResetAndDestroy ();

    }

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

// CFeedsEntity::ConstructL

// Symbian 2nd phase constructor can leave.

// by this method.

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

//

void CFeedsEntity::ConstructL(const CPackedFolder& aPackedFolder)

    {

    CFeedsEntity* rootFolder = NULL;

    CFeedsEntity* currentFolder = NULL;

    CFeedsEntity* folderItem = NULL;

    CFeedsEntity* miniItem = NULL;

    TPtrC title;

    TPtrC url;

    TInt entryId;

    TInt feedId;

    TTime timestamp;

    TInt freq;

    TInt unreadCount;

    TInt status; 

    TBool isMiniItem = EFalse;

    TUint attribute;

    //	CItemMini* miniItem = NULL;

    TPtrC attributeValue;

    ConstructL ();

    // Unpack the packed folder.

    while (aPackedFolder.HasNextToken ())

        {

        TUint token;

        token = aPackedFolder.NextToken ();

        switch (token)

            {

            case EFolderTokenFolderBegin:

                // Get the folder item's attributes.

                aPackedFolder.ExtractAttributes (title, url, entryId, feedId,

                        timestamp, unreadCount, status, freq);

                // CPackedFolders contain a single root folder.  Because of this

                // the first folder should be treated as the root.  "this" 

                // becomes the root CFeedsEntity.

                if ( rootFolder == NULL)

                    {

                    iId = entryId;

                    iType = EFolder;

                    iParent = NULL;

                    iAttrProp->SetStringAttribute (EFolderAttributeTitle, title);

                    iAttrProp->SetIntegerAttribute(EFolderAttributeStatus,status);

                    rootFolder = this;

                    currentFolder = this;

                    }

            	// Otherwise create a subfolder and set its parent.

            	else

                    {

                    folderItem = CFeedsEntity::NewFolderL (title, entryId, status);

                    folderItem->SetFeedInterface (iFeedInterface);

                    // Add the folder to the parent.

                    User::LeaveIfError (currentFolder->iChildren.Append (folderItem));

                    folderItem->iParent = currentFolder;

                    // Set this folder as the active folder.

                    currentFolder = folderItem;

                    }

                break;

            case EFolderTokenFolderEnd:

                // Set the current folder to its parent.

                currentFolder = const_cast<CFeedsEntity*>(currentFolder->iParent);

                break;

            case EFolderTokenFeed:

                // Get the folder item's attributes.

                aPackedFolder.ExtractAttributes (title, url, entryId, feedId,

                        timestamp, unreadCount, status, freq);

                // Create the new feed and add it to the current folder.

                // folderListId is shared by all feeds/folders

                folderItem = CFeedsEntity::NewFeedL (title, url, entryId,

                        feedId, timestamp, status, freq, unreadCount );

                folderItem->SetFeedInterface (iFeedInterface);

                // Add the folder to the parent.

                User::LeaveIfError (currentFolder->iChildren.Append (folderItem));

                folderItem->iParent = currentFolder;

                break;

            case EFolderTokenItemBegin:

                miniItem = CFeedsEntity::NewMiniItemL();

            //	miniItem->iType = EMiniItem;

                CleanupStack::PushL(miniItem);

                isMiniItem = ETrue;

                break;

            case EFolderTokenItemEnd:

                isMiniItem = EFalse;         

                miniItem->SetFeedInterface (iFeedInterface);       

            //    folderItem->AddMiniItem(miniItem);

                User::LeaveIfError (currentFolder->iChildren.Append (miniItem));

               // CleanupStack::Pop(miniItem);

            	break;

            case EPackedTokenAttribute:

                aPackedFolder.ExtractAttributeValue(attribute, attributeValue);

                if (isMiniItem)

                    {

                    miniItem->SetAttribute(attribute, attributeValue);

                    }

                else

                    {

                    // TODO: Panic.

                    }

                break;			

            }

        }

    }

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

// CFeedsEntity::ConstructL

// Symbian 2nd phase constructor can leave.

// by this method.

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

//

void CFeedsEntity::ConstructL(const CPackedFeed& aPackedFeed)

    {

    TBool isFeed = EFalse;

    TBool isItem = EFalse;

    TBool isEnclosure = EFalse;

    CFeedsEntity* item = NULL;

    CFeedsEntity* enclosure = NULL;

    TUint attribute;

    TPtrC attributeValue;

    ConstructL ();

    // Unpack the packed feed.

    while (aPackedFeed.HasNextToken ())

        {

        TUint token;

        token = aPackedFeed.NextToken ();

        switch (token)

            {

            case EFeedTokenFeedBegin:

                isFeed = ETrue;

                break;

            case EFeedTokenItemBegin:

                item = CFeedsEntity::NewL (iFeedInterface);

                item->iType = EFeedsItem;

                item->iParent = this;

                CleanupStack::PushL (item);

                isItem = ETrue;

                break;

            case EFeedTokenEnclosureBegin:

                enclosure = CFeedsEntity::NewL (iFeedInterface);

                enclosure->iType = EFeedsEnclosure;

                enclosure->iParent = item;

                CleanupStack::PushL (enclosure);

                isEnclosure = ETrue;

                break;

            case EFeedTokenFeedEnd:

                isFeed = EFalse;

                break;

            case EFeedTokenItemEnd:

                isItem = EFalse;

                User::LeaveIfError (iChildren.Append (item));

                CleanupStack::Pop (item);

                break;

            case EFeedTokenEnclosureEnd:

                isEnclosure = EFalse;

                User::LeaveIfError (item->iChildren.Append (enclosure));

                CleanupStack::Pop (enclosure);

                break;

            case EPackedTokenAttribute:

                aPackedFeed.ExtractAttributeValue (attribute, attributeValue);

                if ( isEnclosure)

                    {

                    enclosure->SetAttribute (attribute, attributeValue);

                    }

                else

                    if ( isItem)

                        {

                        item->SetAttribute (attribute, attributeValue);

                        }

                    else

                        if ( isFeed)

                            {

                            SetAttribute (attribute, attributeValue);

                            }

                        else

                            {

                            // TODO: Panic.

                            }

                break;

            case EFeedTokenOtherTitle:

                //iOtherTitles++;

                break;

            case EFeedTokenOtherDescription:

                //iOtherDescriptions++;

                break;

            case EFeedTokenOtherLink:

                //iOtherLinks++;

                break;

            default:

                // Ignore

                break;

            };

        }

    }

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

// CFeedsEntity::SetAttribute

//

// adds given attribute in iAttrProp Map

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

//

void CFeedsEntity::SetAttribute(TUint aAttribute, const TPtrC& aAttributeValue)

    {

    switch(iType)

    {

        case EFeed:

            {

            switch(aAttribute)

                {

                case EFeedAttributeUnused:

                case EFeedAttributeTitle:

                case EFeedAttributeLink:

                case EFeedAttributeDescription:

                case EFeedAttributeTimestamp:

                case EFeedAttributeImage:

                case EFeedAttributeTTL:

                case EFeedAttributeSkipHours:

                case EFeedAttributeSkipDays:

                case EFeedAttributeLanguage:

                case EFeedAttributeCopyright:

                case EFeedAttributeEditor:

                case EFeedAttributeWebMaster:

                case EFeedAttributePubDate:

                case EFeedAttributeCategory:

                case EFeedAttributeGenerator:

                case EFeedAttributeDocs:

                case EFeedAttributeCloud:

                case EFeedAttributeRating:

                case EFeedAttributeTextInput:

                case EFeedAttributeAssociatedUrl:

                case EFeedAttributeFeedUrl:

                    iAttrProp->SetStringAttribute (aAttribute, aAttributeValue);

                    break; 

                case EFeedAttributeFeedId:

                    {

                    TLex lex(aAttributeValue);

                    lex.Val (iFeedId);

                    break;