/*

* 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: 

*

*/

// INCLUDES

#include <hbglobal.h>

#include <hbextendedlocale.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediaarray.h>

#include <mpxmedia.h>

#include <vcxmyvideosdefs.h>

#include <qabstractitemmodel.h>

#include "testvideomodel_p.h"

#include "videocollectionutils.h"

#include "videothumbnaildata.h"

#include "videolistdatamodel.h"

#include "mediaobjectfactory.h"

#include "videocollectioncommon.h"

#include "videocollectionutils.h"

#include "metadatasignalspy.h"

#define private public

#include "videolistdatamodel_p.h"

#undef private

const int MEDIA_COUNT = 10;

inline uint qHash(TMPXItemId key) 

{ 

    QPair<uint, uint> keyPair(key.iId1, key.iId2); 

    return qHash(keyPair);

}

int main(int argc, char *argv[])

{

    Q_UNUSED(argc);

    TestVideoModel_p tv;

    int res;

    if(argc > 1)

    {   

        res = QTest::qExec(&tv, argc, argv);

    }

    else

    {

        char *pass[3];

        pass[0] = argv[0];

        pass[1] = "-o";

        pass[2] = "c:\\data\\testvideomodel_p.txt";

        res = QTest::qExec(&tv, 3, pass);

    }    

    return res;

}

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

// initTestCase

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

//

void TestVideoModel_p::initTestCase()

{

    qRegisterMetaType<TMPXItemId>("TMPXItemId");

    mTestObject = 0;

    mMediaFactory = new MediaObjectFactory();

    mStubModel = new VideoListDataModel();

}

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

// init

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

//

void TestVideoModel_p::init()

{

    qRegisterMetaType<QModelIndex>("QModelIndex");

    mTestObject = new VideoListDataModelPrivate(mStubModel);

    QVERIFY(mTestObject);

    VideoCollectionUtils::mPrepareLengthStringReturnValue = "test duration";

    VideoCollectionUtils::mPrepareSizeStringReturnValue = "test size";   

}

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

// cleanup

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

//

void TestVideoModel_p::cleanup()

{

    if(mTestObject)

    {

        delete mTestObject;

        mTestObject = 0;

    }  

}

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

// cleanupTestCase

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

//

void TestVideoModel_p::cleanupTestCase()

{

    delete mMediaFactory;

    delete mStubModel;

}

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

// testInitTNFails

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

//

void TestVideoModel_p::testInitialize()

{   

    // Succeeds.

    QVERIFY(mTestObject->initialize() == 0);

    // Initialize already called.

    QVERIFY(mTestObject->initialize() == 0);

}

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

// testItemCount

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

//

void TestVideoModel_p::testItemCount()

{    

    QVERIFY(mTestObject->getVideoCount() == 0);

    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));    

    mMediaFactory->removeArray();

    mMediaFactory->createMediaItems(MEDIA_COUNT);

    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());

    QVERIFY( mTestObject->getVideoCount() == MEDIA_COUNT);

    disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*)));

}

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

// testGetMediaIdFromIndex

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

//

void TestVideoModel_p::testGetMediaIdFromIndex()

{

    QVERIFY(mTestObject->getMediaIdFromIndex(0) == -1);

    QVERIFY(mTestObject->getMediaIdFromIndex(-1) == -1);

    mMediaFactory->removeArray();

    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));          

    mMediaFactory->createMediaItems(MEDIA_COUNT);

    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());

    QVERIFY(mTestObject->getMediaIdFromIndex(-1) == -1);

    QVERIFY(mTestObject->getMediaIdFromIndex(MEDIA_COUNT) == -1);

    QVERIFY(mTestObject->getMediaIdFromIndex(0) == 0);

    QVERIFY(mTestObject->getMediaIdFromIndex(MEDIA_COUNT - 1) == MEDIA_COUNT - 1);

    // no data

    mTestObject->mMediaData.clear();

    mMediaFactory->removeArray();

    mMediaFactory->createMediaItems(MEDIA_COUNT, MediaDataNone);    

    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());

    QVERIFY(mTestObject->getMediaIdFromIndex(-1) == -1);

    QVERIFY(mTestObject->getMediaIdFromIndex(MEDIA_COUNT) == -1);

    QVERIFY(mTestObject->getMediaIdFromIndex(0) == -1);

    QVERIFY(mTestObject->getMediaIdFromIndex(MEDIA_COUNT - 1) == - 1);

    disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*)));  

}

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

// testGetVideoNameFromIndex

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

//

void TestVideoModel_p::testGetVideoNameFromIndex()

{

    QString expectedName = "";

    QVERIFY(mTestObject->getVideoNameFromIndex(0) == expectedName);

    QVERIFY(mTestObject->getVideoNameFromIndex(-1) == expectedName);

    mMediaFactory->removeArray();

    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));          

    mMediaFactory->createMediaItems(MEDIA_COUNT);

    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());

    QVERIFY(mTestObject->getVideoNameFromIndex(-1) == expectedName);

    QVERIFY(mTestObject->getVideoNameFromIndex(MEDIA_COUNT) == expectedName);

    expectedName = gQTMediaNamePrefix + "0";

    QVERIFY(mTestObject->getVideoNameFromIndex(0) == expectedName);

    expectedName = gQTMediaNamePrefix + QString::number(MEDIA_COUNT - 1);

    QVERIFY(mTestObject->getVideoNameFromIndex(MEDIA_COUNT - 1) == expectedName);

    // no data

    expectedName = "";

    mTestObject->mMediaData.clear();

    mMediaFactory->removeArray();

    mMediaFactory->createMediaItems(MEDIA_COUNT, MediaDataId);    

    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());

    QVERIFY(mTestObject->getVideoNameFromIndex(-1) == expectedName);

    QVERIFY(mTestObject->getVideoNameFromIndex(MEDIA_COUNT) == expectedName);

    QVERIFY(mTestObject->getVideoNameFromIndex(0) == expectedName);

    QVERIFY(mTestObject->getVideoNameFromIndex(MEDIA_COUNT - 1) == expectedName);

    disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))); 

}

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

// testGetVideoThumbnailFromIndex

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

//

void TestVideoModel_p::testGetVideoThumbnailFromIndex()

{

    QVERIFY(mTestObject->getVideoThumbnailFromIndex(0) == 0);

    mMediaFactory->removeArray();

    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));          

    mMediaFactory->createMediaItems(MEDIA_COUNT);

    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());

    QVERIFY(mTestObject->initialize() == 0);

    // invalid indexes

    QVERIFY(mTestObject->getVideoThumbnailFromIndex(-1) == 0);

    QVERIFY(mTestObject->getVideoThumbnailFromIndex(MEDIA_COUNT) == 0);

    // correct indexes

    QVERIFY(mTestObject->getVideoThumbnailFromIndex(0) != 0);

    QVERIFY(mTestObject->getVideoThumbnailFromIndex(MEDIA_COUNT/2) != 0);

    QVERIFY(mTestObject->getVideoThumbnailFromIndex(MEDIA_COUNT - 1) != 0);

    disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))); 

}

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

// testGetCategoryVideoCountFromIndex

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

//

void TestVideoModel_p::testGetCategoryVideoCountFromIndex()

{

    QVERIFY(mTestObject->getCategoryVideoCountFromIndex(0) == 0);

    mMediaFactory->removeArray();

    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));          

    mMediaFactory->createMediaItems(MEDIA_COUNT, MediaDataName | MediaDataId | MediaDetailCategoryVideoCount);

    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());

    QVERIFY(mTestObject->initialize() == 0);

    // invalid indexes

    QVERIFY(mTestObject->getCategoryVideoCountFromIndex(-1) == 0);

    QVERIFY(mTestObject->getCategoryVideoCountFromIndex(MEDIA_COUNT) == 0);

    // correct indexes

    QCOMPARE((int)(mTestObject->getCategoryVideoCountFromIndex(0)), 1);

    QCOMPARE((int)(mTestObject->getCategoryVideoCountFromIndex(MEDIA_COUNT/2)), 1);

    QCOMPARE((int)(mTestObject->getCategoryVideoCountFromIndex(MEDIA_COUNT - 1)), 5);

    disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))); 

}

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

// testGetVideoSizeFromIndex

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

//

void TestVideoModel_p::testGetVideoSizeFromIndex()

{

    QVERIFY(mTestObject->getVideoSizeFromIndex(0) == 0);

    QVERIFY(mTestObject->getVideoSizeFromIndex(-1) == 0);

    mMediaFactory->removeArray();

    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));           

    mMediaFactory->createMediaItems(MEDIA_COUNT);

    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());

    QVERIFY(mTestObject->getVideoSizeFromIndex(-1) == 0);

    QVERIFY(mTestObject->getVideoSizeFromIndex(MEDIA_COUNT) == 0);

    QVERIFY(mTestObject->getVideoSizeFromIndex(0) == 1);

    QVERIFY(mTestObject->getVideoSizeFromIndex(MEDIA_COUNT - 1) == MEDIA_COUNT);

    // data does not exist

    mTestObject->mMediaData.clear();

    mMediaFactory->removeArray();

    mMediaFactory->createMediaItems(MEDIA_COUNT, MediaDataId);    

    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());

    QVERIFY(mTestObject->getVideoSizeFromIndex(-1) == 0);

    QVERIFY(mTestObject->getVideoSizeFromIndex(MEDIA_COUNT) == 0);

    QVERIFY(mTestObject->getVideoSizeFromIndex(0) == 0);

    QVERIFY(mTestObject->getVideoSizeFromIndex(MEDIA_COUNT - 1) == 0);

    disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*)));  

}

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

// testGetVideoAgeProfileFromIndex

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

//

void TestVideoModel_p::testGetVideoAgeProfileFromIndex()

{

    QVERIFY(mTestObject->getVideoAgeProfileFromIndex(0) == 0);

    QVERIFY(mTestObject->getVideoAgeProfileFromIndex(-1) == 0);

    mMediaFactory->removeArray();

    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));           

    mMediaFactory->createMediaItems(MEDIA_COUNT);

    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());

    QVERIFY(mTestObject->getVideoAgeProfileFromIndex(-1) == 0);

    QVERIFY(mTestObject->getVideoAgeProfileFromIndex(MEDIA_COUNT) == 0);

    quint32 excepted = (0%5) + 1;

    QVERIFY(mTestObject->getVideoAgeProfileFromIndex(0) == excepted);

    excepted = ((MEDIA_COUNT - 1)%5) + 1;

    QVERIFY(mTestObject->getVideoAgeProfileFromIndex(MEDIA_COUNT - 1) == excepted);

    // data does not exist

    mTestObject->mMediaData.clear();

    mMediaFactory->removeArray();

    mMediaFactory->createMediaItems(MEDIA_COUNT, MediaDataId);    

    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());

    QVERIFY(mTestObject->getVideoAgeProfileFromIndex(-1) == 0);

    QVERIFY(mTestObject->getVideoAgeProfileFromIndex(MEDIA_COUNT) == 0);

    QVERIFY(mTestObject->getVideoAgeProfileFromIndex(0) == 0);

    QVERIFY(mTestObject->getVideoAgeProfileFromIndex(MEDIA_COUNT - 1) == 0);

    disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*)));

}

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

// testGetVideodurationFromIndex

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

//

void TestVideoModel_p::testGetVideodurationFromIndex()

{

    QVERIFY(mTestObject->getVideodurationFromIndex(0) == 0);

    QVERIFY(mTestObject->getVideodurationFromIndex(-1) == 0);

    mMediaFactory->removeArray();

    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));           

    mMediaFactory->createMediaItems(MEDIA_COUNT);

    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());

    QVERIFY(mTestObject->getVideodurationFromIndex(-1) == 0);

    QVERIFY(mTestObject->getVideodurationFromIndex(MEDIA_COUNT) == 0);

    QVERIFY(mTestObject->getVideodurationFromIndex(0) == 1);

    QVERIFY(mTestObject->getVideodurationFromIndex(MEDIA_COUNT - 1) == MEDIA_COUNT );

    // data does not exist

    mTestObject->mMediaData.clear();

    mMediaFactory->removeArray();

    mMediaFactory->createMediaItems(MEDIA_COUNT, MediaDataId);    

    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());

    QVERIFY(mTestObject->getVideodurationFromIndex(-1) == 0);

    QVERIFY(mTestObject->getVideodurationFromIndex(MEDIA_COUNT) == 0);

    QVERIFY(mTestObject->getVideodurationFromIndex(0) == 0);

    QVERIFY(mTestObject->getVideodurationFromIndex(MEDIA_COUNT - 1) == 0);

    disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*)));

}

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

// testGetVideoDateFromIndex

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

//

void TestVideoModel_p::testGetVideoDateFromIndex()

{

    QDateTime excepted;

    QVERIFY(mTestObject->getVideoDateFromIndex(0) == excepted);

    QVERIFY(mTestObject->getVideoDateFromIndex(-1) == excepted);

    // test when data exists

    mMediaFactory->removeArray();

    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));          

    mMediaFactory->createMediaItems(MEDIA_COUNT);

    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());

    QVERIFY(mTestObject->getVideoDateFromIndex(-1) == excepted);

    QVERIFY(mTestObject->getVideoDateFromIndex(MEDIA_COUNT) == excepted);

    excepted = QDateTime(QDate(2009, 1, 1), QTime(1,1,1,1));

    QCOMPARE(mTestObject->getVideoDateFromIndex(0), excepted);

    excepted = QDateTime(QDate(2009, MEDIA_COUNT, MEDIA_COUNT), QTime(MEDIA_COUNT,MEDIA_COUNT,MEDIA_COUNT,MEDIA_COUNT));

    QCOMPARE(mTestObject->getVideoDateFromIndex(MEDIA_COUNT - 1), excepted);

    // data does not exist

    mTestObject->mMediaData.clear();

    mMediaFactory->removeArray();

    mMediaFactory->createMediaItems(MEDIA_COUNT, MediaDataId);    

    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());

    excepted = QDateTime();

    QVERIFY(mTestObject->getVideoDateFromIndex(-1) == excepted);         

    QVERIFY(mTestObject->getVideoDateFromIndex(MEDIA_COUNT) == excepted);

    QVERIFY(mTestObject->getVideoDateFromIndex(0) == excepted);

    QVERIFY(mTestObject->getVideoDateFromIndex(MEDIA_COUNT - 1) == excepted);

    disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*)));

}

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

// testVideoMarkAndRestoreDeleted

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

//

void TestVideoModel_p::testVideoMarkAndRestoreDeleted()

{

    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));   

    mMediaFactory->removeArray();

    mMediaFactory->createMediaItems(MEDIA_COUNT);

    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());

    VideoListDataModel::mFirstInserted = -1;

    VideoListDataModel::mLastInserted = -1;

    QList<TMPXItemId> idsToRestore;

    // mark few items to be removed then restore them 

    // NOTE: since item marking decreases item count by one,

    //       we need to mark items starting from biggest index,

    //       otherwise we might end up to mark invalid items

    QModelIndex index = mStubModel->index(MEDIA_COUNT-1, 0, QModelIndex());

    idsToRestore.append(mTestObject->markVideoRemoved(index));    

    index = mStubModel->index(MEDIA_COUNT / 2, 0, QModelIndex());

    idsToRestore.append(mTestObject->markVideoRemoved(index));

    index = mStubModel->index(0, 0, QModelIndex());

    idsToRestore.append(mTestObject->markVideoRemoved(index));

    QVERIFY(mTestObject->getVideoCount() == (MEDIA_COUNT - 3) );

    mTestObject->restoreRemoved(&idsToRestore);

    QVERIFY(VideoListDataModel::mFirstInserted == MEDIA_COUNT - 3);

    QVERIFY(VideoListDataModel::mLastInserted == MEDIA_COUNT - 1);

    QVERIFY(mTestObject->getVideoCount() == MEDIA_COUNT);

    idsToRestore.clear();

    mMediaFactory->removeArray();

    mMediaFactory->createMediaItems(MEDIA_COUNT);

    emit signalNewVideoList(mMediaFactory->copyOfMediaArray());

    VideoListDataModel::mFirstInserted = -1;

    VideoListDataModel::mLastInserted = -1;

    // mark few items to be removed then restore them 

    index = mStubModel->index(MEDIA_COUNT-1, 0, QModelIndex());

    idsToRestore.append(mTestObject->markVideoRemoved(index));    

    index = mStubModel->index(MEDIA_COUNT / 2, 0, QModelIndex());

    idsToRestore.append(mTestObject->markVideoRemoved(index));

    index = mStubModel->index(0, 0, QModelIndex());

    idsToRestore.append(mTestObject->markVideoRemoved(index));

    QVERIFY(mTestObject->getVideoCount() == (MEDIA_COUNT - 3) );

    mTestObject->restoreRemoved(&idsToRestore);

    QVERIFY(VideoListDataModel::mFirstInserted == MEDIA_COUNT - 3);

    QVERIFY(VideoListDataModel::mLastInserted == MEDIA_COUNT - 1);

    VideoListDataModel::mFirstInserted = -1;

    VideoListDataModel::mLastInserted = -1;

    idsToRestore.clear();

    index = mStubModel->index(MEDIA_COUNT, 0, QModelIndex());

    idsToRestore.append(mTestObject->markVideoRemoved(index));    

    mTestObject->restoreRemoved(&idsToRestore);

    QVERIFY(VideoListDataModel::mFirstInserted == -1);

    QVERIFY(VideoListDataModel::mLastInserted == -1);

    disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*)));

}

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

// testGetFilePathFromIndex

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

//