/*

* 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:    Class for handling mpx collection interactions*

*/

#include <bldvariant.hrh>

#include "IptvDebug.h"

#include "CIptvUtil.h"

#include <mpxcollectionutility.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmediageneraldefs.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxcollectionmessagedefs.h>

#include <mpxcollectionpath.h>

#include <mpxmessage2.h>

#include <mpxcollectionmessage.h>

#include <mpxlog.h>

#include <mpxitemid.h>

#include <mpxmessagecontainerdefs.h>

#include <vcxmyvideosdefs.h>

#include <vcxmyvideosuids.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxcollectioncommanddefs.h>

#include "CIptvMyVideosGlobalFileId.h"

#include "vcxnsmpxcollectionclienthandler.h"

#include "vcxnscontentclienthandler.h"

#include "vcxnsuiengine.h"

#include "vcxnseventrouter.h"

#include "vcxnscontentprovider.h"

#include "vcxnsservice.h"

#include "vcxnscontent.h"

#include "vcxnscontentaccess.h"

#include "vcxnsdownloadupdater.h"

const TInt KMpxMediaId2 = 0;

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

//

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

//

CVcxNsMpxCollectionClientHandler::CVcxNsMpxCollectionClientHandler( CVcxNsUiEngine& aUiEngine )

  : iUiEngine( aUiEngine ),

    iMarkAsWatchedId( KErrNotFound )

    {

    }

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

//

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

//

CVcxNsMpxCollectionClientHandler* CVcxNsMpxCollectionClientHandler::NewL( 

                                                           CVcxNsUiEngine& aUiEngine )

    {

    CVcxNsMpxCollectionClientHandler* self =

        new (ELeave) CVcxNsMpxCollectionClientHandler( aUiEngine );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;    

    }

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

//

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

//

void CVcxNsMpxCollectionClientHandler::ConstructL()

    {

    iCollectionUtility = MMPXCollectionUtility::NewL( this, KMcModeDefault );

    CMPXCollectionPath* path = CMPXCollectionPath::NewL();

    CleanupStack::PushL( path );

    path->AppendL( KVcxUidMyVideosMpxCollection );

    iCollectionUtility->Collection().OpenL( *path );

    CleanupStack::PopAndDestroy( path );

    iDownloadUpdater = CVcxNsDownloadUpdater::NewL( this );

    iGetMediaDetailWait = new ( ELeave ) CActiveSchedulerWait;

    }

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

//

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

//

CVcxNsMpxCollectionClientHandler::~CVcxNsMpxCollectionClientHandler()

    {

    iLastFetchedMedias.ResetAndDestroy();

    iResumeArray.Close();

    delete iDownloadUpdater;

    if( iCollectionUtility )

        {

        iCollectionUtility->Close();

        }

    iDownloadedContents.Reset();

    delete iGetMediaDetailWait;

    }

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

//

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

//  

TInt CVcxNsMpxCollectionClientHandler::DownloadL( CVcxNsService& aService, 

                                                  CVcxNsContent& aContent )

    {

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::DownloadL(s,c) IN");

    aContent.SetDlFailNotified( EFalse );

    aContent.SetUsernameL( aService.GetUserName() );

    aContent.SetPasswordL( aService.GetPassword() );

    if( aContent.PendingCommand() == CVcxNsContent::EVcxNsMpxContentCommandStartDownload ||

        aContent.PendingCommand() == CVcxNsContent::EVcxNsMpxContentCommandResumeDownload ||

        aContent.PendingCommand() == CVcxNsContent::EVcxNsMpxContentCommandWaitingForMpxItem )

        {

        // Download request is already made, but 

        // Collection hasn't processed it yet.

        return KErrAlreadyExists;

        }

    if( aContent.PendingCommand() == CVcxNsContent::EVcxNsMpxContentCommandCancelDownload )

        {

        // Download request is already made, and user has cancelled

        // it already, but Collection hasn't process the requests yet.

        // So reset just the pending cmd data.

        aContent.SetPendingCommand( CVcxNsContent::EVcxNsMpxContentCommandNone  );

        return KErrNone;

        }

    TInt ret( KErrGeneral );

    if( aContent.GetUrl( CVcxNsContent::EVcxContentTypeVideo ).Length() == 0 )

        {

        ret = KErrArgument;

        }

    else 

        {

        TUint32 transactionId( 0 );

        ret = DownloadL( aContent.GetUrl( CVcxNsContent::EVcxContentTypeVideo ),

                         aContent.GetName(),

                         aService.GetIap(),                          

                         aService.GetIsReadOnlyIap(),

                         aService.GetUserName(),

                         aService.GetPassword(),

                         transactionId );

        if ( ret == KErrNone )

            {

            // To the download list. Content from Mpx events

            // is resolved from the list.

            AppendToDownloadList( &aContent );

            aContent.SetPendingCommand( CVcxNsContent::EVcxNsMpxContentCommandStartDownload );

            aContent.SetCmdTransactionId( transactionId );

            iUiEngine.ContentProvider()->UpdateContent( &aContent );

            }

        else

            {

            aContent.SetPendingCommand( CVcxNsContent::EVcxNsMpxContentCommandNone );

            }

        }

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::DownloadL(s,c) OUT");

    return ret;

    }

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

//

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

//  

TInt CVcxNsMpxCollectionClientHandler::DownloadL( const TDesC& aAddress,

                                                  const TDesC& aName,

                                                  TUint32 aIapId,

                                                  TBool aIsReadOnlyIap,

                                                  const TDesC& aUserName,

                                                  const TDesC& aPassword,

                                                  TUint32& aTransactionId )

    {

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::DownloadL() start");

    CMPXCommand* cmd = CMPXCommand::NewL();

    CleanupStack::PushL( cmd ); // 1->

    cmd->SetTObjectValueL( KMPXCommandGeneralId, KVcxCommandIdMyVideos );

    cmd->SetTObjectValueL( KVcxMediaMyVideosCommandId, KVcxCommandMyVideosStartDownload );

    cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, EFalse /* = async */ );

    cmd->SetTObjectValueL( KVcxMediaMyVideosTransactionId, ++iLatestTransactionId );

    aTransactionId = iLatestTransactionId;

    TUid colId = TUid::Uid( KVcxUidMyVideosMpxCollection );

    cmd->SetTObjectValueL( KMPXCommandGeneralCollectionId, colId.iUid );

    CMPXMedia* startDownloadReq = CMPXMedia::NewL();

    CleanupStack::PushL( startDownloadReq ); // 2->

    TUint flags = ( aIsReadOnlyIap ? EVcxMyVideosServiceHasReadOnlyIap : 0 ) | 

                        EVcxMyVideosSilent;

    startDownloadReq->SetTObjectValueL( KMPXMediaGeneralFlags, flags );

    if( aIsReadOnlyIap )

        {

        startDownloadReq->SetTObjectValueL( KVcxMediaMyVideosIapId, aIapId );

        }

    else

        {

        // not a read only iap, set iap 0 so download utility 

        // can select iap via connectionutility

        startDownloadReq->SetTObjectValueL( KVcxMediaMyVideosIapId, 0 );

        }

    startDownloadReq->SetTextValueL( KVcxMediaMyVideosRemoteUrl, aAddress );

    startDownloadReq->SetTextValueL( KVcxMediaMyVideosUsername, aUserName );

    startDownloadReq->SetTextValueL( KVcxMediaMyVideosPassword, aPassword );

    startDownloadReq->SetTextValueL( KMPXMediaGeneralTitle, aName );

    cmd->SetCObjectValueL<CMPXMedia>( KMPXCommandColAddMedia, startDownloadReq );

    iCollectionUtility->Collection().CommandL( *cmd );

    CleanupStack::PopAndDestroy( startDownloadReq ); // <-2

    CleanupStack::PopAndDestroy( cmd );              // <-1

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::DownloadL() exit");

    return KErrNone;

    }

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

//

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

//  

TInt CVcxNsMpxCollectionClientHandler::PauseDownloadL( CVcxNsContent& aContent )

    {

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::PauseDownloadL IN");

    TInt ret( KErrNone );

    if( !aContent.GetMpxMedia() ||

             !aContent.GetMpxMedia()->ValueTObjectL<TUint32>( KVcxMediaMyVideosDownloadId ) )

        {

        IPTVLOGSTRING_LOW_LEVEL(

             "CVcxNsMpxCollectionClientHandler::PauseDownloadL OUT, bad argument");

        ret = KErrArgument;

        }

    else

        {

        CMPXMedia* media = CMPXMedia::NewL( *(aContent.GetMpxMedia()) );

        CleanupStack::PushL( media );

        CMPXCommand* cmd = CMPXCommand::NewL();

        CleanupStack::PushL( cmd );

        cmd->SetTObjectValueL( KMPXCommandGeneralId, KVcxCommandIdMyVideos );

        cmd->SetTObjectValueL( KVcxMediaMyVideosCommandId, KVcxCommandMyVideosPauseDownload );

        cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, EFalse );

        TUid colId = TUid::Uid( KVcxUidMyVideosMpxCollection );

        cmd->SetTObjectValueL( KMPXCommandGeneralCollectionId, colId.iUid );

        TUint32 downloadId = media->ValueTObjectL<TUint32>( KVcxMediaMyVideosDownloadId );            

        cmd->SetTObjectValueL( KVcxMediaMyVideosDownloadId, downloadId );        

        iCollectionUtility->Collection().CommandL( *cmd );

        CleanupStack::PopAndDestroy( cmd );

        CleanupStack::PopAndDestroy( media );

        }

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::PauseDownloadL OUT");

    return ret;

    }

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

//

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

//  

TInt CVcxNsMpxCollectionClientHandler::ResumeDownloadL( CVcxNsContent& aContent )

    {

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::ResumeDownloadL IN");

    aContent.SetDlFailNotified( EFalse );

    TInt ret( KErrNone );

    if( !aContent.GetMpxMedia() || 

             !aContent.GetMpxMedia()->ValueTObjectL<TUint32>( KVcxMediaMyVideosDownloadId ) )

        {

        ret = KErrArgument;

        IPTVLOGSTRING_LOW_LEVEL(

            "CVcxNsMpxCollectionClientHandler::ResumeDownloadL OUT, bad argument");

        }

    else

        {

        CMPXMedia* media = CMPXMedia::NewL( *(aContent.GetMpxMedia()) );

        CleanupStack::PushL( media );

        CMPXCommand* cmd = CMPXCommand::NewL();

        CleanupStack::PushL( cmd );

        cmd->SetTObjectValueL( KMPXCommandGeneralId, KVcxCommandIdMyVideos );

        cmd->SetTObjectValueL( KVcxMediaMyVideosCommandId, KVcxCommandMyVideosStartDownload );

        cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, EFalse );

        TUid colId = TUid::Uid( KVcxUidMyVideosMpxCollection );

        cmd->SetTObjectValueL( KMPXCommandGeneralCollectionId, colId.iUid );

        cmd->SetTObjectValueL( KVcxMediaMyVideosTransactionId, ++iLatestTransactionId );

        IPTVLOGSTRING2_LOW_LEVEL("CVcxNsMpxCollectionClientHandler:: TR ID = %d", iLatestTransactionId);

        TUint32 transactionId = iLatestTransactionId;

        media->SetTObjectValueL( KVcxMediaMyVideosIapId, 0 );

        media->SetTextValueL( KVcxMediaMyVideosUsername, aContent.GetUsername() );

        media->SetTextValueL( KVcxMediaMyVideosPassword, aContent.GetPassword() );

        cmd->SetCObjectValueL<CMPXMedia>( KMPXCommandColAddMedia, media );

        iCollectionUtility->Collection().CommandL( *cmd );

        CleanupStack::PopAndDestroy( cmd );

        CleanupStack::PopAndDestroy( media );

        aContent.SetPendingCommand( CVcxNsContent::EVcxNsMpxContentCommandResumeDownload );

        aContent.SetCmdTransactionId( transactionId );

        AppendToDownloadList( &aContent );

        iUiEngine.ContentProvider()->UpdateContent( &aContent );

        TUint32 mpxId = aContent.GetMpxId();

		if ( iResumeArray.Find( mpxId ) == KErrNotFound )

		    { 

            iResumeArray.AppendL( mpxId );

			}

        IPTVLOGSTRING_LOW_LEVEL(

            "CVcxNsMpxCollectionClientHandler::ResumeDownloadL OUT, cmd OK.");

        }

    return ret;

    }

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

//

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

//  

TInt CVcxNsMpxCollectionClientHandler::CancelDownloadL( CVcxNsContent& aContent )

    {

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::CancelDownloadL IN");

    aContent.SetDlFailNotified( EFalse );

    TInt ret( KErrNone );

    if( !aContent.GetMpxMedia(CVcxNsContent::EVcxContentTypeVideo) )

        {

        // Even though cancel cannot be called now, it must be called later

        // So mark the content to be pending the cancel.

        aContent.SetPendingCommand ( CVcxNsContent::EVcxNsMpxContentCommandCancelDownload );

        // Incremet cmd id, so the cmd is not reset when this 

        // content's previous cmd's complete msg arrives.

        aContent.SetCmdTransactionId ( ++iLatestTransactionId );

        // Redraw the fake state to user.

        iUiEngine.ContentProvider()->UpdateContent( &aContent );

        }

    else

        {

        CMPXCommand* cmd = CMPXCommand::NewL();

        CleanupStack::PushL( cmd );

        cmd->SetTObjectValueL( KMPXCommandGeneralId, KVcxCommandIdMyVideos );

        cmd->SetTObjectValueL( KVcxMediaMyVideosCommandId, 

                               KVcxCommandMyVideosCancelDownload );

        cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, EFalse /* = async */ );

        TUid colId = TUid::Uid( KVcxUidMyVideosMpxCollection );

        cmd->SetTObjectValueL( KMPXCommandGeneralCollectionId, colId.iUid );

        CMPXMedia* media = aContent.GetMpxMedia( CVcxNsContent::EVcxContentTypeVideo );

        if ( media )

            {

            cmd->SetCObjectValueL<CMPXMedia>( KMPXCommandColAddMedia, media );

            cmd->SetTObjectValueL( KVcxMediaMyVideosTransactionId, ++iLatestTransactionId );

            iCollectionUtility->Collection().CommandL( *cmd );

            }

        CleanupStack::PopAndDestroy( cmd );

        aContent.SetPendingCommand ( CVcxNsContent::EVcxNsMpxContentCommandCancelDownload );

        aContent.SetCmdTransactionId ( iLatestTransactionId );

        }

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::CancelDownloadL OUT");

    return ret;

    }

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

//

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

//  

void CVcxNsMpxCollectionClientHandler::LoadMpxMediaObjectsL()

    {

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::LoadMpxMediaObjectsL IN");

    RArray<TUint32> ids;

    CleanupClosePushL( ids );

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

        {

        if( (iDownloadedContents[i])->GetMpxId() )

            {

            ids.Append( (iDownloadedContents[i])->GetMpxId() );

            }

        }

    GetMediaByMpxIdReqL( ids );

    CleanupStack::PopAndDestroy( &ids );

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::LoadMpxMediaObjectsL OUT");

    }

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

//

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

//  

void CVcxNsMpxCollectionClientHandler::LoadMpxMediaObjectL( TUint32 aMpxId )

    {

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::LoadMpxMediaObjectL IN");

    RArray<TUint32> id;

    CleanupClosePushL( id );

    id.Append( aMpxId );

    GetMediaByMpxIdReqL( id );

    CleanupStack::PopAndDestroy( &id );

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::LoadMpxMediaObjectL OUT");

    }

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

//

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

//  

void CVcxNsMpxCollectionClientHandler::HandleCollectionMediaL( const CMPXMedia& aMedia, 

                             TInt aError )

    {

    IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::HandleCollectionMediaL");

    if ( aError == KErrNone )

        {

        SearchAndAddMpxMediaL( & const_cast<CMPXMedia&>( aMedia ) );

        if ( aMedia.IsSupported( KMPXMediaGeneralId ) )

            {

            iLastFetchedMedias.ResetAndDestroy();

            iLastFetchedMedias.Append( CMPXMedia::NewL( aMedia ) );

            }

        }

    if ( iGetMediaDetailWait->IsStarted() )

        {

        iGetMediaDetailWait->AsyncStop();

        }

    }

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

// CVcxNsMpxCollectionClientHandler::HandleCollectionMessage

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

//

void CVcxNsMpxCollectionClientHandler::HandleCollectionMessage(CMPXMessage* aMessage, 

                                                               TInt aError )

    {

    TRAPD( err, ExplodeCollectionMessagesL( aMessage, aError ) );

    if ( err != KErrNone )

        {

        IPTVLOGSTRING2_LOW_LEVEL(

"CVcxNsMpxCollectionClientHandler::ExplodeCollectionMessagesL() leaved with error code %d", err);

        }

    }

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

// CVcxNsMpxCollectionClientHandler::ExplodeCollectionMessagesL

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

//

void CVcxNsMpxCollectionClientHandler::ExplodeCollectionMessagesL(CMPXMessage* aMessage, 

                                                                  TInt aError )

    {

    if ( !aMessage )

        {

        return;

        }

    TInt cmdId = aMessage->ValueTObjectL<TMPXMessageId>( KMPXMessageGeneralId );

    TInt myVideosCmd = -1;