/*
* 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:  The client side connection to the root-folder on the FeedsSever.
*
*/

#include <feedsserverclient.h>
#include <feedsserverfolderitem.h>
#include "FolderItemRequestHandlers.h"
#include "FeedRequestHandlers.h"
#include "ClientRequestHandlers.h"

#include "Logger.h"

// -----------------------------------------------------------------------------
// RFolderItem::RFolderItem
//
// C++ default constructor can NOT contain any code that
// might leave.
// -----------------------------------------------------------------------------
//
EXPORT_C RFolderItem::RFolderItem( MFolderItemObserver& aObserver, TInt aFolderListId, TBool aItemTitleNeed ):
        iObserver(aObserver), iFolderItem(NULL), iFolderListId(aFolderListId), iItemTitleNeed(aItemTitleNeed), 
        iFeedsServer( NULL )
    {
    CFolderItemRequestHandler *folderReqHandler = NULL;
    TRAP_IGNORE(
    {
    folderReqHandler =   CFolderItemRequestHandler::NewL();
    CleanupStack::PushL(folderReqHandler);
    iActiveRequests.AppendL(folderReqHandler);
    CleanupStack::Pop(folderReqHandler);
    });
    }

// -----------------------------------------------------------------------------
// RFolderItem::Open
//
// Opens a session to the given folder on the server.
// -----------------------------------------------------------------------------
//
EXPORT_C TInt RFolderItem::Open(RFeedsServer &aFeedsServer)
    {

    iFeedsServer = &aFeedsServer;
    RFeedsInterface *feedsInterface = iFeedsServer->iActiveRequests[0]->GetFeedInterface();
    iActiveRequests[0]->SetFeedInterface(feedsInterface);
    iFeedsServer->SetServerFolderItem(*this);
    return KErrNone;   
    }

// -----------------------------------------------------------------------------
// RFolderItem::Close
//
// Closes the connection to the server.
// -----------------------------------------------------------------------------
//
EXPORT_C void RFolderItem::Close()
    {    
    iFeedsServer = NULL;
    iActiveRequests.ResetAndDestroy();    
    delete iFolderItem;
    iFolderItem = NULL;
    }


// -----------------------------------------------------------------------------
// RFolderItem::RequestHandlerCompletedL
//
// Notifies the observer that the request is completed.
// -----------------------------------------------------------------------------
//
void RFolderItem::RequestHandlerCompletedL(CTransaction& aTrans, 
        TInt aStatus)
    {
    switch (aTrans.Type())
        {
        case CTransaction::EFetchRootFolderItem:
            if(aStatus == KErrNone)
               {
               delete iFolderItem;
               iFolderItem = NULL;

               iFolderItem = CFolderItem::NewL(iFolderListId, iActiveRequests[0]->GetFeedInterface()->RootFolder());
               // Notify the observer that the request has completed.
               iObserver.FolderItemRequestCompleted(aStatus, (CRequestHandler::TRequestHandlerType)aTrans.Type());
               }
            break;

        case CTransaction::EWatchForChanges:
            // Only notify the user if an error occurred.
            if (aStatus != KErrNone)
                {
                iObserver.FolderItemRequestCompleted(aStatus, (CRequestHandler::TRequestHandlerType)aTrans.Type());
                }
            break;

        // no need to notify observer now, server will notify us later
        // assuming FetchRootFolder or WatchFolderList has been called before
        case CTransaction::EAddFolderItem:
        case CTransaction::EDeleteFolderItem:
        case CTransaction::EChangeFolderItem:
        case CTransaction::EMoveFolderItem:
        case CTransaction::EMoveFolderItemTo:
        case CTransaction::EUpdateFolderItem:
        break;

        case CTransaction::EImportOPML:
        case CTransaction::EExportOPML:
            iObserver.FolderItemRequestCompleted(aStatus, (CRequestHandler::TRequestHandlerType)aTrans.Type());
            break;

        default:
            // Notify the observer that the request has completed.
            iObserver.FolderItemRequestCompleted(aStatus, (CRequestHandler::TRequestHandlerType)aTrans.Type());
            break;
        }
    }

// -----------------------------------------------------------------------------
// RFolderItem::NetworkConnectionNeededL()
// -----------------------------------------------------------------------------
//
void RFolderItem::NetworkConnectionNeededL( TInt* aConnectionPtr, TInt& aSockSvrHandle,
                                            TBool& aNewConn, TApBearerType& aBearerType )
    {
    iActiveRequests[0]->SetOperationRequested( EFalse);//reset the flag
    iObserver.NetworkConnectionNeededL( aConnectionPtr, aSockSvrHandle, aNewConn, aBearerType );
    }

// -----------------------------------------------------------------------------
// RFolderItem::FetchRootFolderItemL
//
// Fetches the root FolderItem.  FetchRootFolderItemCompleted is called upon completion.
// -----------------------------------------------------------------------------
//
EXPORT_C void RFolderItem::FetchRootFolderItemL()
    {
    iActiveRequests[0]->GetFeedInterface()->GetRootFolderL(); 
    }

// -----------------------------------------------------------------------------
// RFolderItem::AddFolderItemL
//
// Request the feeds server to add a new folder item.
// -----------------------------------------------------------------------------
//
EXPORT_C void RFolderItem::AddFolderItemL(const TDesC& aName, const TDesC& aUrl,
        TBool aIsFolder, const CFolderItem& aParent)
    {
    CFeedsMap* map = CFeedsMap::NewL();
    CleanupStack::PushL(map);

    map->SetStringAttribute(EFeedAttributeTitle, aName);
    map->SetStringAttribute(EFeedAttributeLink, aUrl);

    if(aIsFolder)
        {
        iActiveRequests[0]->GetFeedInterface()->AddL(EFolder, *map, *(aParent.iFeedsEntity));	
        }
    else
        {
        iActiveRequests[0]->GetFeedInterface()->AddL(EFeed, *map, *(aParent.iFeedsEntity)); 
        }
    CleanupStack::PopAndDestroy(map);
    }

// -----------------------------------------------------------------------------
// RFolderItem::ChangeFolderItemL
//
// Request the feeds server to change the folder item.  If this is a folder then
// KNullDesC should be passed to the aUrl argument.
// -----------------------------------------------------------------------------
//
EXPORT_C void RFolderItem::ChangeFolderItemL(const CFolderItem& aFolderItem, 
        const TDesC& aTitle, const TDesC& aUrl)
    {
    CFeedsMap* map = CFeedsMap::NewL();

    map->SetStringAttribute(EFeedAttributeTitle,aTitle);
    map->SetStringAttribute(EFeedAttributeLink,aUrl);

    iActiveRequests[0]->GetFeedInterface()->SetAttributeL(*(aFolderItem.iFeedsEntity), *map);

    delete map;
    }

// -----------------------------------------------------------------------------
// RFolderItem::DeleteFolderItemsL
//
// Request the feeds server to delete the folder items.
// -----------------------------------------------------------------------------
//
EXPORT_C void RFolderItem::DeleteFolderItemsL(RPointerArray<const CFolderItem>& 
        aFolderItems)
    {
    RPointerArray<const CFeedsEntity> feedsEntities;
    CleanupClosePushL(feedsEntities);

    for(TInt index = 0; index <aFolderItems.Count(); index ++)
        {
        feedsEntities.Append(aFolderItems[index]->iFeedsEntity);
        }
    
    iActiveRequests[0]->GetFeedInterface()->DeleteL(feedsEntities);
    // Clean up
    CleanupStack::PopAndDestroy(/*feedsEntities*/);
    }

// -----------------------------------------------------------------------------
// RFolderItem::ExportFolderItemsL
//
// Request the feeds server to export the folder items.
// -----------------------------------------------------------------------------
//
EXPORT_C void RFolderItem::ExportFolderItemsL(RPointerArray<const CFolderItem>& 
        aFolderItems, const TDesC &aExportFileName)
    {
    if(aExportFileName.Length() <=0)
        {
        User::Leave(KErrArgument);
        }

    if(aFolderItems.Count() <=0)
        {
        User::Leave(KErrArgument);
        }

    RPointerArray<const CFeedsEntity> feedsEntities;
    CleanupClosePushL(feedsEntities);

    for(TInt index = 0; index <aFolderItems.Count(); index ++)
        {
        feedsEntities.Append(aFolderItems[index]->iFeedsEntity);
        }
    
    iActiveRequests[0]->GetFeedInterface()->ExportFoldersL(feedsEntities, aExportFileName);
    // Clean up
    CleanupStack::PopAndDestroy(/*feedsEntities*/);
    }

// -----------------------------------------------------------------------------
// RFolderItem::MoveFolderItemsToL
//
// Request the feeds server to move the folder items to a different parent. 
// -----------------------------------------------------------------------------
//
EXPORT_C void RFolderItem::MoveFolderItemsToL(RPointerArray<const CFolderItem>& 
        aFolderItems, const CFolderItem& aParent)
    {

    if (aFolderItems.Count() > 0)
        {        
        RPointerArray<const CFeedsEntity> feedsEntities;
        CleanupClosePushL(feedsEntities);

        for(TInt index = 0; index <aFolderItems.Count(); index ++)
           {
    	   feedsEntities.Append(aFolderItems[index]->iFeedsEntity);
           }
               
        iActiveRequests[0]->GetFeedInterface()->MoveToFolderL(feedsEntities, *(aParent.iFeedsEntity));
        // Clean up
        CleanupStack::PopAndDestroy(/*feedsEntities*/);
        }
    }

// -----------------------------------------------------------------------------
// RFolderItem::MoveFolderItemsL
//
// Request the feeds server to move the folder items to a different index. 
// -----------------------------------------------------------------------------
//
EXPORT_C void RFolderItem::MoveFolderItemsL(RPointerArray<const CFolderItem>& 
        aFolderItems, TInt aIndex)
    {
    if (aFolderItems.Count() > 0)
        {        
        RPointerArray<const CFeedsEntity> feedsEntities;
        CleanupClosePushL(feedsEntities);

        for(TInt index = 0; index <aFolderItems.Count(); index ++)
           {
    	   feedsEntities.Append(aFolderItems[index]->iFeedsEntity);
           }

        iActiveRequests[0]->GetFeedInterface()->MoveL(feedsEntities, aIndex);
        // Clean up
        CleanupStack::PopAndDestroy(/*feedsEntities*/);
       }
    }

// -----------------------------------------------------------------------------
// RFolderItem::UpdateFolderItemsL
//
// Request the feeds server to update the folder items (refresh them from the web). 
// -----------------------------------------------------------------------------
//
EXPORT_C void RFolderItem::UpdateFolderItemsL(const RPointerArray<const CFolderItem>& 
        aFolderItems)
    {
        if (aFolderItems.Count() > 0)
        {  
                
        iActiveRequests[0]->SetOperationRequested( ETrue);
        RPointerArray<const CFeedsEntity> feedsEntities;

        CleanupClosePushL(feedsEntities);

        for(TInt index = 0; index <aFolderItems.Count(); index ++)
           {
    	   feedsEntities.Append(aFolderItems[index]->iFeedsEntity);
           }
        iActiveRequests[0]->GetFeedInterface()->UpdateL(feedsEntities);

        // Clean up
        CleanupStack::PopAndDestroy(/*feedsEntities*/);
        }
    }

// -----------------------------------------------------------------------------
// RFolderItem::UpdateAllL
//
// Request the feeds server to update all of the folder items (refresh them 
// from the web) associated with current given folder list.
// -----------------------------------------------------------------------------
//
EXPORT_C void RFolderItem::UpdateAllL()
    {
    RPointerArray<const CFeedsEntity> feedsEntities;

    CleanupClosePushL(feedsEntities);

    iActiveRequests[0]->SetOperationRequested( ETrue);
    feedsEntities.Append((iActiveRequests[0]->GetFeedInterface()->RootFolder()));
    iActiveRequests[0]->GetFeedInterface()->UpdateL(feedsEntities);

    // Clean up
    CleanupStack::PopAndDestroy(/*feedsEntities*/);
    }

// -----------------------------------------------------------------------------
// RFolderItem::WatchFolderListL
//
// Sets up a notifier to execute when the folder list changes.
// -----------------------------------------------------------------------------
//
EXPORT_C void RFolderItem::WatchFolderListL()
    {
    iActiveRequests[0]->GetFeedInterface()->WatchFolderListL();
    }


// -----------------------------------------------------------------------------
// RFolderItem::HasRootFolderItem
//
// Returns ETrue if it has an available root folder.
// -----------------------------------------------------------------------------
//
EXPORT_C TBool RFolderItem::HasRootFolderItem() const
    {
    return (iFolderItem != NULL);
    }


// -----------------------------------------------------------------------------
// RFolderItem::RootFolderItem
//
// Once fetched, it returns the CFolderItem.  This method panics the client if it is 
// called before the folder item is available.
// -----------------------------------------------------------------------------
//
EXPORT_C const CFolderItem& RFolderItem::RootFolderItem() const
    {
    return *iFolderItem;
    }


// -----------------------------------------------------------------------------
// RFolderItem::ImportOPMLL
//
// Import OPML file passed from the client.
// -----------------------------------------------------------------------------
//
EXPORT_C void RFolderItem::ImportOPMLL( const TDesC& aPath, TBool /*aClearFolderList=EFalse*/ )
    {
    iActiveRequests[0]->GetFeedInterface()->ImportOPMLL(aPath);
    }
