/*

* 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:  Represent a session on server side.

*

*/

#include "FeedsDatabase.h"

#include "FeedsServer.h"

#include "FeedsServerMsg.h"

#include "FeedsServerSession.h"

#include "SessionHttpConnection.h"

#include "Logger.h"

#include "PackedFeed.h"

#include "PackedFolder.h"

_LIT(KTempDirName, "c:\\system\\temp\\");

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

// CFeedsServerSession::NewL

//

// Two-phased constructor.

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

//

CFeedsServerSession* CFeedsServerSession::NewL(CFeedsServer& aFeedsServer)

    {

    CFeedsServerSession*  self;

    self = new (ELeave) CFeedsServerSession(aFeedsServer);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CFeedsServerSession::NewL

//

// Symbian 2nd phase constructor can leave.

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

//

void CFeedsServerSession::ConstructL()

    {

    // Create the shared http connection in this sesssion

    iHttpConnection = CSessionHttpConnection::NewL( *this );

    iLazyCaller = CIdle::NewL(CActive::EPriorityIdle);

    iOPMLImportTask = NULL;

    iExportOPMLFileName = NULL;

    iCurrOp = iPrevOp = 0;

    }

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

// CFeedsServerSession::CFeedsServerSession

//

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

// might leave.

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

//

CFeedsServerSession::CFeedsServerSession(CFeedsServer& aFeedsServer):

        iLeakTracker(CLeakTracker::EFeedsServerSession), iFeedsServer(aFeedsServer), 

        iStoreFeeds(ETrue), iWatchFolderListId(KNoFolderListId),iGetFeedCalled(EFalse)

    {

    iFeedsServer.SessionOpened();

    }

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

// CFeedsServerSession::~CFeedsServerSession

//

// Destructor.

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

//

CFeedsServerSession::~CFeedsServerSession()

    {

    delete iUpdateAllFeedsTask;

    delete iUpdateFeedTask;

    delete iPackedFeed;

    delete iPackedFolder;

    delete iOPMLImportTask;

    delete iExportOPMLFileName;

    delete iLazyCaller;

    if (iHttpConnection != NULL)

        {

        iHttpConnection->CancelAnyConnectionAttempt();

        iHttpConnection->AutoDelete();

        }

    iFeedsServer.SessionClosed();

    }

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

// CFeedsServerSession::StartWait

//

// Notifies the observer that the task is about to start a lengthy 

// operation.  In response the observer could display somekind of 

// status indicator.

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

//

void CFeedsServerSession::StartWait()

    {

    // Ignore.

    }

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

// CFeedsServerSession::SetConnection

//

// Set client's connection to use by the session http connection.

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

//

void CFeedsServerSession::SetConnectionL(const RMessage2& aMessage)

    {

    RBufReadStream  stream;

    CBufFlat*       requestBuff;    

    TInt            nameLength;

    HBufC*          nameBuf;

    TPtr            name( NULL, 0 );

    TInt            bearerType;

    TInt            setConn = EFalse;

    // Extract the request.

	requestBuff = CBufFlat::NewL(128);

    CleanupStack::PushL(requestBuff);

	TInt len = aMessage.GetDesLengthL(KFeedsServerPackedRequestArg);

	requestBuff->ExpandL(0, len);

	TPtr8  reqPtr((TUint8*) requestBuff->Ptr(0).Ptr(), len);

    aMessage.ReadL(KFeedsServerPackedRequestArg, reqPtr, 0);

    // Unpack the request.

    stream.Open(*requestBuff, 0);

    CleanupClosePushL(stream);

    nameLength = stream.ReadUint16L();

    nameBuf = HBufC::NewLC( nameLength );

    name.Set( (TUint16*) nameBuf->Ptr(), nameLength, nameLength );

    stream.ReadL( name, nameLength );

    bearerType = stream.ReadUint16L();

    // Update the http connection.

    setConn = iHttpConnection->SetConnection( name, bearerType );

	CleanupStack::PopAndDestroy( nameBuf );

	CleanupStack::PopAndDestroy( /*stream*/ );

	CleanupStack::PopAndDestroy( requestBuff );

    if( setConn )

        {

        // make sure there's update task needing connection

        __ASSERT_DEBUG( (iUpdateAllFeedsTask != NULL) || (iUpdateFeedTask != NULL), User::Panic(_L("FeedsSvrSes SetConn"), KErrGeneral) );

        SetClientPendingMessage( aMessage );

        }

    else

        {

        // make sure no update task needing connection when CancelAll occurs bf SetConnection

        __ASSERT_DEBUG( (iUpdateAllFeedsTask == NULL) && (iUpdateFeedTask == NULL), User::Panic(_L("FeedsSvrSes SetConn"), KErrGeneral) );

        aMessage.Complete( KErrCancel );

        }

    }

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

// CFeedsServerSession::NetworkConnectionNeededL

//

// Called upon connection request.

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

//

void CFeedsServerSession::NetworkConnectionNeededL()

    {

    // Tell the client that the connection is needed from client app.

    TPckgBuf<TFeedsServerResponseType> responseType( EFeedsServerConnectionNeeded );

    User::LeaveIfError( iPendingMessage.Write(KFeedsServerPackedResponseTypeArg, 

            responseType, 0) );

    // Notify the client of result.

    CompleteClientPendingMessage();

    }

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

// CFeedsServerSession::Completed

//

// Called upon completion of the update feed task.

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

//

void CFeedsServerSession::Completed(CPackedFeed* aPackedFeed, const TDesC& aFeedUrl,TInt aFeedId,

        TInt aStatusCode)

    {

    // Do the real work...

    TRAPD(err, CompletedHelperL(aPackedFeed, aFeedUrl,aFeedId));

    if (err != KErrNone)

        {

        delete aPackedFeed;

        FEED_LOG1(_L("Feeds"), _L("Feeds_Errors.log"), 

                EFileLoggingModeAppend, _L("CFeedsServerSession::Completed: %d."), err);

        aStatusCode = err;

        }

    if(aStatusCode != KErrCancel && aStatusCode != KErrNoMemory)

    	{

        // Update the database.

        TRAP_IGNORE(iFeedsServer.Database().UpdateFeedStatusL(aFeedId,aStatusCode));

    	}

    // Solution of bug EMWG-7AC9HK,using CIdle class to send tocken instead sending it directly

    iLazyCaller->Start(TCallBack(LazyCallBack,this));

    // Compact the database.

    iFeedsServer.Database().Compact();

    iPendingStatus = aStatusCode;

    iPendingMessageHandle = iPendingMessage.Handle();

    }

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

// CFeedsServerSession::CompletedHelperL

//

// Called upon completion of the task -- helper method for Completed.

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

//

void CFeedsServerSession::CompletedHelperL(CPackedFeed*& aPackedFeed, 

        const TDesC& aFeedUrl,TInt aFeedId)

    {

    // A new packed feed is ready, send the first part to the client.

    if (aPackedFeed != NULL)

        {

        // If need be update the database.

        if (iStoreFeeds)

            {      

            //TInt  feedId;

            // Update the database to reflect the feed.

            iFeedsServer.iFeedsDatabase->UpdateFeedL(*aPackedFeed, aFeedUrl,aFeedId, iFolderListId);

            // Extract the feed from the database rather than passing along the 

            // oringal feed as the database contains other feed information.

            delete aPackedFeed;

            aPackedFeed = NULL;

            //(void) iFeedsServer.iFeedsDatabase->FeedIdFromUrlL(aFeedUrl, iFolderListId, feedId);

            // Extract the updated feed.

            iPackedFeed = CPackedFeed::NewL();

            iFeedsServer.iFeedsDatabase->ExtractFeedL(aFeedId, *iPackedFeed);

            }    

        // If the feed isn't being stored in the database then just use the feed.

        else

            {

            iPackedFeed = aPackedFeed;

            aPackedFeed = NULL;      

            }

        }

    }

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

// CFeedsServerSession::UpdateAllFeedsProgress

//

// Called to notify the obsever how many feeds remain to be updated.

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

//

void CFeedsServerSession::UpdateAllFeedsProgress(TInt /*aMaxCount*/, TInt /*aRemaining*/)

    {

    // TODO:

    }

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

// CFeedsServerSession::UpdateAllFeedsCompleted

//

// Called upon completion of the task.

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

//

void CFeedsServerSession::UpdateAllFeedsCompleted(TInt aStatusCode)

    {

    TRAP_IGNORE(UpdateAllFeedsCompletedL(aStatusCode));

    }

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

// CFeedsServerSession::UpdateAllFeedsCompletedL

//

// Called upon completion of the task.

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

//

void CFeedsServerSession::UpdateAllFeedsCompletedL(TInt aStatusCode)

    {

    // Delete the task.

    iUpdateAllFeedsTask->AutoDelete();

    iUpdateAllFeedsTask = NULL;

    // Compact the database.

    iFeedsServer.Database().Compact();

    // Tell the client that the manual update is done.

    TPckgBuf<TFeedsServerResponseType> responseType( EFeedsServerManualUpdateDone );

    User::LeaveIfError( iPendingMessage.Write(KFeedsServerPackedResponseTypeArg, 

            responseType, 0) );

    // Notify the client.

    CompleteClientPendingMessage( aStatusCode );

    // Notify all open sessions that the folder list just changed -- the 

    // last-update timestamp.

    if (aStatusCode == KErrNone)

        {        

        iFeedsServer.NotifyFolderListChanged( iUpdateAllFolderListId );

        }

    }

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

// CFeedsServerSession::ServiceL

//

// Client-server framework calls this function to handle messages from client.  

// This calls DispatchMessageL under the trap harness in order to propagate 

// any errors back to the client (via RMessage2::Complete) rather than leaving.

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

//

void CFeedsServerSession::ServiceL(const RMessage2& aMessage)

    {

    // Ignore these messages...

    switch (aMessage.Function())

        {

        case EFeedsServerOpenFeedSession:

        case EFeedsServerOpenFolderSession:

            aMessage.Complete(KErrNone);

            return;

        case EFeedsServerCloseFeedSession:

            CancelFeedRequestsL();

            aMessage.Complete(KErrNone);

            return;

		case EFeedsServerCompleteWatchFolderList:

            if (iWatchFolderListId != KNoFolderListId)

                {                

                iWatchFolderListMessage.Complete(KErrCancel);

                }

			aMessage.Complete(KErrNone);

            return;

        case EFeedsServerCloseFolderSession:       

            CancelFolderRequestsL();

            aMessage.Complete(KErrNone);

            return;

        case EFeedsServerCompleteWatchSettings:

            if ( iWatchSettingsMessage.IsNull() == EFalse )

                {                

                iWatchSettingsMessage.Complete(KErrCancel);

                }

            aMessage.Complete(KErrNone);

            return;

        }

    // allow following functions while update or updateAll is occuring

    if ( (aMessage.Function() != EFeedsServerCancelAll) &&

         (aMessage.Function() != EFeedsServerSetConnection) &&

         ( (iUpdateAllFeedsTask != NULL) || (iUpdateFeedTask != NULL) ) )

        {

        User::Leave(KErrServerBusy);

        }

    // Handle the message.

    // TODO: Does this need to be TRAPed?  I think it "Complete" the message 

    //       with the leave err if it does.  If so the trap can be removed.

    TRAPD(err, DispatchMessageL(aMessage));

    // Propagate any errors back to the client.

    if (err != KErrNone)

        {

        aMessage.Complete(err);

        }

    }

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

// CFeedsServerSession::DispatchMessageL

//

// Handle messages from the client.

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

//

void CFeedsServerSession::DispatchMessageL(const RMessage2 &aMessage)

    {

    // Ensure the server is ready.

    iFeedsServer.WakeupServerL();

    iCurrOp = aMessage.Function();

    if ( (!IsSpaceAvailableL()) && ((iCurrOp != EFeedsServerGetRootFolder) ||

                                (iCurrOp != EFeedsServerWatchFolderList) || (iCurrOp != EFeedsServerGetSettings) ||

                                (iCurrOp != EFeedsServerWatchSettings) || (iCurrOp != EFeedsServerSetConnection) ||

                                (iCurrOp != EFeedsServerDisconnectManualUpdateConnection) ||

                                (iCurrOp != EFeedsServerCancelAll) || (iCurrOp != EFeedsServerGetFeed) ||

                                (iCurrOp != EFeedsServerPrintDBTables)))

        {

        User::Leave(KErrNoMemory);

        }

    switch (iCurrOp)

        {

	    case EFeedsServerGetRootFolder:

	        GetRootFolderL(aMessage);

            break;

	    case EFeedsServerAddFolderItem:

	        AddFolderItemL(aMessage);

            break;

	    case EFeedsServerChangeFolderItem:

	        ChangeFolderItemL(aMessage);

            break;

	    case EFeedsServerDeleteFolderItems:

	        DeleteFolderItemsL(aMessage);

            break;

	    case EFeedsServerMoveFolderItems:

	        MoveFolderItemsL(aMessage);

            break;

	    case EFeedsServerMoveFolderItemsTo:

	        MoveFolderItemsToL(aMessage);

            break;

	    case EFeedsServerUpdateFolderItems:

	        UpdateFolderItemsL(aMessage);

            break;

        case EFeedsServerWatchFolderList:

            WatchFolderListL(aMessage);

            break;

	    case EFeedsServerImportOPML:

	        ImportOPMLAsyncL( aMessage );

            break;

	    case EFeedsServerExportOPML:

	        ExportOPMLL( aMessage );

            break;

	    case EFeedsServerGetSettings:

	        GetSettingsL(aMessage);

            break;

	    case EFeedsServerChangeSettings:

	        ChangeSettingsL(aMessage);

            break;

        case EFeedsServerWatchSettings:

            WatchSettingsL(aMessage);

            break;

	    case EFeedsServerSetConnection:

	        SetConnectionL(aMessage);

            break;

	    case EFeedsServerDisconnectManualUpdateConnection:

	        DisconnectManualUpdateConnection(aMessage);

            break;

	    case EFeedsServerCancelAll:

	        CancelAllRequestsL(aMessage);

            break;

	    case EFeedsServerGetFeed:

	        GetFeedL(aMessage);

            break;

	    case EFeedsServerChangeFeedItemStatus:

	        ChangeFeedItemStatusL(aMessage);

            break;

	    case EFeedsServerPrintDBTables:

            #if defined(_DEBUG)

             //   iFeedsServer.iFeedsDatabase->DebugPrintTablesL();

            #endif

            aMessage.Complete(KErrNone);

            break;

        default:

            {

            // TODO:CR RMessage.Panic...

            iFeedsServer.PanicClient(aMessage, EFeedsServerBadRequest);

            break;

            }

        }

        iPrevOp = iCurrOp;

    }

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

// CFeedsServerSession::GetRootFolderL

//

// Returns the root folder item -- fetching it if need be.

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