/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:   VideoCollectionClient class implementation

* 

*/

// INCLUDE FILES

#include <QObject>

#include <centralrepository.h>

#include <mpxcollectionutility.h>

#include <mpxcollectionpath.h>

#include <mpxmediageneraldefs.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxmessage2.h>

#include <mpxcollectionmessagedefs.h>

#include <mpxcollectionmessage.h>

#include <mpxmessagecontainerdefs.h>

#include <mpxmediacontainerdefs.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxcollectioncommanddefs.h>

#include <vcxmyvideosuids.h>

#include "videodatasignalreceiver.h"

#include "videocollectionclient.h"

#include "videocollectionlistener.h"

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

// VideoCollectionClient()

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

//

VideoCollectionClient::VideoCollectionClient() :

mCollectionUtility(0),

mCollectionOpenStatus(ECollectionNotOpen),  

mCollectionListener(0),

mOpenCategoryAlbum(0,9),

mCollectionPathLevel(VideoCollectionClient::ELevelInvalid)

{

}

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

// initialize()

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

//

int VideoCollectionClient::initialize()

{

    if(mCollectionUtility && mCollectionListener)

    {

        // already initialized

        return 0;

    }

    if(!mCollectionListener)

    {

        mCollectionListener = new VideoCollectionListener(*this);

        if(!mCollectionListener)

        {

            return -1;

        }

    }

    if(!mCollectionUtility)

    {

        TRAPD( error, mCollectionUtility = MMPXCollectionUtility::NewL( mCollectionListener, KMcModeDefault ) );

        if(error)

        {

            delete mCollectionListener;

            mCollectionListener = 0;

            return error;

        }

    }

    return 0;

}

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

// ~VideoCollectionClient()

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

//

VideoCollectionClient::~VideoCollectionClient()

{

    if (mCollectionUtility)

    {

        // closing deallocates collection utility pointer

        mCollectionUtility->Close();

    }

    delete mCollectionListener;

}

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

// setVideoModelObserver

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

//

int VideoCollectionClient::connectCollectionSignalReceiver(

                                            VideoDataSignalReceiver *signalReceiver)

{

    if(!mCollectionListener || !signalReceiver)

    {   

        return -1;

    }

    if(!QObject::connect(mCollectionListener, SIGNAL(newVideoList(CMPXMediaArray*)),

                       signalReceiver, SLOT(newVideoListSlot(CMPXMediaArray*)),

                       Qt::DirectConnection))

    {

        return -1;

    }

    if(!QObject::connect(mCollectionListener, SIGNAL(videoListAppended(CMPXMediaArray*)),

                           signalReceiver, SLOT(appendVideoListSlot(CMPXMediaArray*)),

                           Qt::DirectConnection))

    {

        return -1;

    }

    if(!QObject::connect(mCollectionListener, SIGNAL(newVideoAvailable(CMPXMedia*)),

                       signalReceiver, SLOT(newVideoAvailableSlot(CMPXMedia*)),

                       Qt::DirectConnection))

    {

        return -1;

    }

    if(!QObject::connect(mCollectionListener, SIGNAL(videoDeleted(TMPXItemId)),

                       signalReceiver, SLOT(videoDeletedSlot(TMPXItemId)),

                       Qt::DirectConnection))

    {

        return -1;

    }

    if(!QObject::connect(mCollectionListener, SIGNAL(videoDeleteCompleted(int, QList<TMPXItemId>*)),

                       signalReceiver, SLOT(videoDeleteCompletedSlot(int, QList<TMPXItemId>*)),

                       Qt::DirectConnection))

    {

        return -1;

    }

    if(!QObject::connect(mCollectionListener, SIGNAL(videoDetailsCompleted(TMPXItemId)),

                       signalReceiver, SLOT(videoDetailsCompletedSlot(TMPXItemId)),

                       Qt::DirectConnection))

    {

        return -1;

    }

    return 0;

}

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

// categoryIds

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

//

void VideoCollectionClient::getCategoryIds(int& id, int& type)

{

    id = mOpenCategoryAlbum.iId1; //unique id

    type = mOpenCategoryAlbum.iId2; //category or album

}

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

// getCollectionLevel

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

//

int VideoCollectionClient::getCollectionLevel()

{

    return mCollectionPathLevel;

}

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

// getOpenStatus

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

//

int VideoCollectionClient::getOpenStatus()

{

	return mCollectionOpenStatus;

}

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

// setOpenStatus

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

//

void VideoCollectionClient::setOpenStatus(int status)

{

    mCollectionOpenStatus = status;

    if(mCollectionOpenStatus == ECollectionOpened)

    {

        startOpenCurrentState();

    }

}

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

// startOpenCollection

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

//

int VideoCollectionClient::startOpenCollection(int level)

{

    if(!mCollectionUtility)

    {

        return -1;

    }

	if((mCollectionOpenStatus == ECollectionOpening) && (getCollectionLevel() == level))

    {

        // allready opening/opened

        return 0;

    }

    mCollectionOpenStatus = ECollectionNotOpen;

    TRAPD(error, startOpenCollectionL(level));

    return error;

}

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

// startOpenCurrentState

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

//

int VideoCollectionClient::startOpenCurrentState()

{

    int error = -1;

    if(mCollectionUtility && mCollectionOpenStatus == ECollectionOpened)

    {

        TRAP(error, mCollectionUtility->Collection().OpenL());

    }

    return error;

}

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

// deleteFile

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

int VideoCollectionClient::deleteVideos(QList<TMPXItemId> *mediaIds)

{  

    if(!mCollectionUtility || !mediaIds)

    {

        return -1;

    }    

    TRAPD(error, deleteVideosL(*mediaIds));

    return error;    

}

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

// openMedia

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

//

int VideoCollectionClient::openVideo(TMPXItemId &mediaId)

{

    if(!mCollectionUtility)

    {

        return -1;

    } 

    TInt error;

    if (getCollectionLevel() == VideoCollectionClient::ELevelVideos)

    {

    	TRAP(error, openVideoL(mediaId));

    }

    else

    {

    	TRAP(error, openCategoryL(mediaId));

    }

    return error;

}

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

// back

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

//

int VideoCollectionClient::back()

{

    if(!mCollectionUtility)

    {

        return -1;

    } 

    TRAPD(error, backL());

    return error;

}

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

// fetchMpxMediaByMpxId

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

//

int VideoCollectionClient::fetchMpxMediaByMpxId(TMPXItemId &mpxId)

{

    if(!mCollectionUtility)

    {

        return -1;

    }

    TRAPD(error, fetchMpxMediaByMpxIdL(mpxId));

    return error;

}

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

// getVideoDetails

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

//

int VideoCollectionClient::getVideoDetails(TMPXItemId &mediaId)

{

    if(!mCollectionUtility)

    {

        return -1;

    }

    TRAPD(error, getVideoDetailsL(mediaId));

    return error;

}

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

// addNewCollection

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

//

int VideoCollectionClient::addNewCollection(QString name, QString thumbnail, QList<TMPXItemId> mediaIds)

{

    if(!mCollectionUtility)

    {

        return -1;

    }

    TRAPD(error, addNewCollectionL(name, thumbnail, mediaIds));

    return error;

}

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

// startOpenCollectionL

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

//

void VideoCollectionClient::startOpenCollectionL(int level)

{

    if(!mCollectionUtility)

    {

        User::Leave(KErrGeneral);

    }

    CMPXCollectionPath* collectionPath = CMPXCollectionPath::NewL();

    CleanupStack::PushL( collectionPath );

    collectionPath->AppendL( KVcxUidMyVideosMpxCollection );

    if (level == VideoCollectionClient::ELevelVideos)

    {

    	collectionPath->AppendL( KVcxMvcCategoryIdAll );

		mOpenCategoryAlbum.iId1 = KVcxMvcCategoryIdAll;

    	mOpenCategoryAlbum.iId2 = 1;

    	mCollectionPathLevel = VideoCollectionClient::ELevelVideos;

    }

    else

    {

    	mOpenCategoryAlbum.iId1 = 0;

    	mOpenCategoryAlbum.iId2 = 9;

    	mCollectionPathLevel = VideoCollectionClient::ELevelCategory;

    }

    mCollectionUtility->Collection().OpenL( *collectionPath );

    CleanupStack::PopAndDestroy( collectionPath );  

    mCollectionListener->setRequestNewMediaArray(true);

    mCollectionOpenStatus = ECollectionOpening;

}

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

// deleteVideosL

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

//

void VideoCollectionClient::deleteVideosL(QList<TMPXItemId> &mediaIds)

{

    if(!mCollectionUtility || mediaIds.count() == 0)

    {

        User::Leave(KErrGeneral);

    }

    CMPXMediaArray* mediasToDelete = CMPXMediaArray::NewL();

    CleanupStack::PushL( mediasToDelete );

    CMPXMedia* media = NULL;

    TMPXItemId currentId;

    foreach(currentId, mediaIds)

    {

        media = CMPXMedia::NewL();

        CleanupStack::PushL( media );

        media->SetTObjectValueL( KMPXMediaGeneralId, currentId );

        mediasToDelete->AppendL( *media );

        CleanupStack::PopAndDestroy( media );

    }

    CMPXCommand* cmd = CMPXMedia::NewL();

    CleanupStack::PushL( cmd );

    cmd->SetTObjectValueL( KMPXCommandGeneralId, KVcxCommandIdMyVideos );

    cmd->SetTObjectValueL( KVcxMediaMyVideosCommandId, KVcxCommandMyVideosDelete );    

    cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, EFalse );

    cmd->SetTObjectValueL( KMPXCommandGeneralCollectionId, 

                           TUid::Uid( KVcxUidMyVideosMpxCollection ) );

    cmd->SetCObjectValueL( KMPXMediaArrayContents, mediasToDelete );

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

    CleanupStack::PopAndDestroy( cmd );  

    CleanupStack::PopAndDestroy( mediasToDelete ); 

}

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

// openVideoL

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

//

void VideoCollectionClient::openVideoL(TMPXItemId &videoId)

{

    if(!mCollectionUtility)

    {

        User::Leave(KErrGeneral);

    } 

    CMPXCollectionPath* path = CMPXCollectionPath::NewL();

    CleanupStack::PushL( path );

    path->AppendL( KVcxUidMyVideosMpxCollection );

    path->AppendL( KVcxMvcCategoryIdAll );

    path->AppendL( TMPXItemId( videoId, 0 ) );

    path->SelectL( TMPXItemId( videoId, 0 ) );

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

    CleanupStack::PopAndDestroy( path );  

}

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

// openCategoryL

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

//

void VideoCollectionClient::openCategoryL(TMPXItemId &id)

{    

    if(!mCollectionUtility)

    {

        User::Leave(KErrGeneral);

    } 

    CMPXCollectionPath* collectionPath = CMPXCollectionPath::NewL();

    CleanupStack::PushL( collectionPath );

    collectionPath->AppendL( KVcxUidMyVideosMpxCollection );

    collectionPath->AppendL( id );

    mCollectionUtility->Collection().OpenL( *collectionPath );

    CleanupStack::PopAndDestroy( collectionPath );  

    mCollectionListener->setRequestNewMediaArray(true);

	mOpenCategoryAlbum.iId1 = id;

	mOpenCategoryAlbum.iId2 = 1;

	mCollectionPathLevel = VideoCollectionClient::ELevelVideos;

    mCollectionOpenStatus = ECollectionOpening;

}

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

// backL

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

//

void VideoCollectionClient::backL()

{

    if(!mCollectionUtility)

    {

        User::Leave(KErrGeneral);

    } 

    if (getCollectionLevel() > 2 )

    {

    	mCollectionUtility->Collection().BackL();

    	mCollectionOpenStatus = ECollectionOpening;

    	mCollectionListener->setRequestNewMediaArray(true);

    	mOpenCategoryAlbum.iId1 = 0;

    	mOpenCategoryAlbum.iId2 = 9;

    	mCollectionPathLevel = VideoCollectionClient::ELevelCategory;

    }

}

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

// getVideoDetailsL

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

//

void VideoCollectionClient::getVideoDetailsL(TMPXItemId &videoId)

{

    if(!mCollectionUtility)

    {

        User::Leave(KErrGeneral);

    }

    CMPXCommand* cmd = CMPXCommand::NewL();

    CleanupStack::PushL( cmd );

    cmd->SetTObjectValueL( KMPXCommandGeneralId, KVcxCommandIdMyVideos );

    cmd->SetTObjectValueL( KVcxMediaMyVideosCommandId, KVcxCommandMyVideosGetMediaFullDetailsByMpxId );

    cmd->SetTObjectValueL( KMPXMediaGeneralId, videoId );

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

    CleanupStack::PopAndDestroy( cmd );  

}

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

// addNewCollectionL

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

//

void VideoCollectionClient::addNewCollectionL(QString name, QString thumbnail, QList<TMPXItemId> mediaIds)

{

    if(!mCollectionUtility)

    {

        User::Leave(KErrGeneral);

    }

    CMPXCommand* cmd = CMPXCommand::NewL();

    CleanupStack::PushL( cmd );

    cmd->SetTObjectValueL( KMPXCommandGeneralId, KVcxCommandIdMyVideos );

    cmd->SetTObjectValueL( KVcxMediaMyVideosCommandId, -1 );

    cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, ETrue );

    cmd->SetTObjectValueL( KMPXMediaGeneralTitle, name );

    cmd->SetTObjectValueL( KMPXMediaGeneralThumbnail1, thumbnail );

    // TODO real command id missing, uncomment only after the collection supports adding collections

//    mCollectionUtility->Collection().CommandL( *cmd );

    CleanupStack::PopAndDestroy( cmd );

    if(mediaIds.size() > 0) {

        cmd = CMPXCommand::NewL();

        CleanupStack::PushL( cmd );

        CMPXMediaArray* idMediaArray = CMPXMediaArray::NewL();