/*

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

*

*/

#include "t_tsmodel.h"

#include <qservicemanager.h>

#include <QtTest/QtTest>

#include "tsmodel.h"

#include "afmanager.h"

#include <afstorageglobals.h>

#include "tstaskchangeinfo.h"

#include <hbicon.h>

#define TSTASKMONITOR_TEST 1

const int dataSetsCount(50);

const char serviceName [] = "TestActivityService";

const char ActivityIconKeyword [] = "screenshot";

const char ActivityVisibleKeyword [] = "visible";

//TEST CASES

void T_TsModel::testData()

{

    QVERIFY(mModel);

    QVERIFY(activityService());

    for (int dataSet(0); dataSet < activityDataSetsCount(); ++dataSet) {

        QList<QVariantHash>data(activityDataSet(dataSet));

        //provide test data to TestActivityManager

        QMetaObject::invokeMethod(activityService(),

                                  "setActivitiesList",

                                  Q_ARG(QList<QVariantHash>, data));

        QList<TsTaskChange> applications(appDataSetFull(dataSet));

        QMetaObject::invokeMethod(mAppSrv,

                                  "setTaskList",

                                  Q_ARG(QList<TsTaskChange>, applications));

        //force data update on model. framework doesnt provide observer functionality

        mModel->fullUpdate();

        int offset =0;

        //Verify data. Applications come first...

        foreach ( TsTaskChange application, applications) {

            if(application.first.changeType() == TsTaskChangeInfo::EChangeCancel ) {

                continue;

            }

            QVERIFY(application.second->name() == mModel->data(mModel->index(offset), Qt::DisplayRole).toString());

            //icon can't be realy checked, but can be called

            mModel->data(mModel->index(offset), Qt::DecorationRole);

            QVERIFY(application.second->isClosable() == mModel->data(mModel->index(offset), Qt::UserRole + 1).toBool());//is closable

            QVERIFY(!mModel->data(mModel->index(offset), Qt::UserRole + 100).isValid());//call some unsupported role

            ++offset;//move to next model row

        }

        //Activity come second

        QList<QVariantHash>::const_iterator activity(data.begin());

        for (; activity != data.end(); ++activity) {

            QString debstr = mModel->data(mModel->index(offset), Qt::DisplayRole).toString();

            QVERIFY(0>=mModel->data(mModel->index(offset), Qt::DisplayRole).toString().length());

            //icon can't be realy checked, but can be called

            mModel->data(mModel->index(offset), Qt::DecorationRole);

            QVERIFY(!mModel->data(mModel->index(offset), Qt::UserRole + 1).toBool());//is closable

            QVERIFY(!mModel->data(mModel->index(offset), Qt::UserRole + 100).isValid());//call some unsupported role

            ++offset;//move to next model row

        }

        //call data out of range

        QVERIFY(!mModel->data(mModel->index(-1), Qt::DisplayRole).isValid());

    }

}

void T_TsModel::testRowCount()

{

    QVERIFY(mModel);

    QVERIFY(activityService());

    for (int dataSet(0); dataSet < activityDataSetsCount(); ++dataSet) {

        QList<QVariantHash> activity(activityDataSet(dataSet));

        //provide test data to TestActivityManager

        QMetaObject::invokeMethod(activityService(),

                                  "setActivitiesList",

                                  Q_ARG(QList<QVariantHash>, activity));

        QList<TsTaskChange> applications(appDataSetFull(dataSet));

        //provide test data to TestActivityManager

        QMetaObject::invokeMethod(mAppSrv,

                                  "setTaskList",

                                  Q_ARG(QList<TsTaskChange>, applications));

        //force data update on model. framework doesnt provide observer functionality

        mModel->fullUpdate();

        QVERIFY(mModel->rowCount() <= (activity.count() + applications.count()));

    }

}

void T_TsModel::testOpenApplication()

{

    QMetaObject::invokeMethod(activityService(),

                              "setActivitiesList",

                              Q_ARG(QList<QVariantHash>, activityDataSet(1)));

    mModel->fullUpdate();

    for (int i =0; i < mModel->rowCount(); ++i) {

        mModel->openApplication(mModel->index(i));//just call without veryfication

    }

    mModel->openApplication(mModel->index(-1));//just call without veryfication

}

void T_TsModel::testCloseApplication()

{

    QMetaObject::invokeMethod(activityService(),

                              "setActivitiesList",

                              Q_ARG(QList<QVariantHash>, activityDataSet(1)));

    mModel->fullUpdate();

    for (int i =0; i < mModel->rowCount(); ++i) {

        mModel->closeApplication(mModel->index(i));//just call without veryfication

    }

    mModel->closeApplication(mModel->index(-1));//just call without veryfication

}

void T_TsModel::testActivityWithNoIdDisplaysProperApplicationName()

{

    // prepare activity entry with no activity ID, but with proper application name

    QVariantHash activity;

    RProcess process;

    activity.insert(ActivityApplicationKeyword, static_cast<int>(process.SecureId().iId));

    // prepare data set with only prepared activity

    QVERIFY(QMetaObject::invokeMethod(activityService(),

                                      "setActivitiesList",

                                      Q_ARG(QList<QVariantHash>, QList<QVariantHash>() << activity)));

    QVERIFY(QMetaObject::invokeMethod(mAppSrv,

                                  "setTaskList",

                                  Q_ARG(QList<TsTaskChange>, QList<TsTaskChange>())));

    mModel->fullUpdate();

    // verify the application name is correctly returned as a DisplayRole

    QCOMPARE(mModel->rowCount(), 1);

    QVERIFY(mModel->index(0).isValid());

    QVERIFY(!mModel->data(mModel->index(0), Qt::DisplayRole).toString().isEmpty()); 

}

void T_TsModel::testDataChangedSignalIsEmittedWhenActivityScreenshotIsUpdated()

{

    // prepare activity entry

    QVariantHash activity;

    activity.insert(ActivityIconKeyword, "FakeScreenshotPath");

    // prepare data set with only prepared activity

    QVERIFY(QMetaObject::invokeMethod(activityService(),

                                      "setActivitiesList",

                                      Q_ARG(QList<QVariantHash>, QList<QVariantHash>() << activity)));

    QVERIFY(QMetaObject::invokeMethod(mAppSrv,

                                  "setTaskList",

                                  Q_ARG(QList<TsTaskChange>, QList<TsTaskChange>())));

    mModel->fullUpdate();

    // prepare signal spy    

    qRegisterMetaType<QModelIndex>("QModelIndex");

    QSignalSpy spy(mModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)));

    QVERIFY(spy.isValid());

    // getting the decoration role should trigger asynchronous screenshot retrieval and dataChanged signal emission

    QCOMPARE(mModel->rowCount(), 1);

    QVERIFY(mModel->index(0).isValid());

    mModel->data(mModel->index(0), Qt::DecorationRole);

    // verify proper data passed in signal

    QCOMPARE(spy.count(), 1);

    QCOMPARE(spy.first().at(0).value<QModelIndex>().row(), 0);

    QCOMPARE(spy.first().at(1).value<QModelIndex>().row(), 0);

}

void T_TsModel::testCustomNameIsUsedIfPresent()

{

    RProcess process;

    int applicationId = static_cast<int>(process.SecureId().iId);

    // prepare activity entries

    QVariantHash activityWithCustomName;

    activityWithCustomName.insert(ActivityApplicationName, "Custom Activity Name");

    activityWithCustomName.insert(ActivityApplicationKeyword, applicationId);

    QVariantHash otherActivity;

    otherActivity.insert(ActivityApplicationKeyword, applicationId);

    // prepare data set with only prepared activities

    QVERIFY(QMetaObject::invokeMethod(activityService(),

                                      "setActivitiesList",

                                      Q_ARG(QList<QVariantHash>, QList<QVariantHash>() << activityWithCustomName << otherActivity)));

    QVERIFY(QMetaObject::invokeMethod(mAppSrv,

                                  "setTaskList",

                                  Q_ARG(QList<TsTaskChange>, QList<TsTaskChange>())));

    mModel->fullUpdate();

    // first activity uses custom name

    QCOMPARE(mModel->rowCount(), 2);

    QCOMPARE(mModel->data(mModel->index(0), Qt::DisplayRole), QVariant("Custom Activity Name"));

    // second one didn't define custom name, so it uses application name

    QVERIFY(!mModel->data(mModel->index(1), Qt::DisplayRole).toString().isEmpty()); 

}

void T_TsModel::testInsert1()

{

    QVERIFY(mModel);

    clearModel();

    QVERIFY(QMetaObject::invokeMethod(mAppSrv,

                                   "setTaskList",

                                   Q_ARG(QList<TsTaskChange>, changeDataSet5New())));

    QCOMPARE(mModel->rowCount(), 5);

    QVERIFY(QMetaObject::invokeMethod(mAppSrv,

                                   "setTaskList",

                                   Q_ARG(QList<TsTaskChange>, changeDataSetInsert1(3))));

    QCOMPARE(mModel->rowCount(), 6);    

    QVERIFY(changeDataSetInsert1(3)[0].second->name() == mModel->data(mModel->index(3), Qt::DisplayRole).toString());

}

void T_TsModel::testDelete1()

{

    QVERIFY(mModel);

    clearModel();

    QVERIFY(QMetaObject::invokeMethod(mAppSrv,

                                   "setTaskList",

                                   Q_ARG(QList<TsTaskChange>, changeDataSet5New())));

    QCOMPARE(mModel->rowCount(), 5);

    QVERIFY(QMetaObject::invokeMethod(mAppSrv,

                                   "setTaskList",

                                   Q_ARG(QList<TsTaskChange>, changeDataSetDelete1(1))));

    QCOMPARE(mModel->rowCount(), 4);    

    QCOMPARE(changeDataSet5New()[3].second->name(), mModel->data(mModel->index(1), Qt::DisplayRole).toString());    

}

void T_TsModel::testChange1()

{

    QVERIFY(mModel);

    clearModel();

    QVERIFY(QMetaObject::invokeMethod(mAppSrv,

                                   "setTaskList",

                                   Q_ARG(QList<TsTaskChange>, changeDataSet5New())));

    QCOMPARE(mModel->rowCount(), 5);

    QVERIFY(QMetaObject::invokeMethod(mAppSrv,

                                   "setTaskList",

                                   Q_ARG(QList<TsTaskChange>, changeDataSetChange1(2))));

    QCOMPARE(mModel->rowCount(), 5);    

    QCOMPARE(changeDataSetChange1(2)[0].second->name(), mModel->data(mModel->index(2), Qt::DisplayRole).toString());      

}

void T_TsModel::testMove1()

{

    QVERIFY(mModel);

    clearModel();

    QVERIFY(QMetaObject::invokeMethod(mAppSrv,

                                   "setTaskList",

                                   Q_ARG(QList<TsTaskChange>, changeDataSet5New())));

    QCOMPARE(mModel->rowCount(), 5);

    QVERIFY(QMetaObject::invokeMethod(mAppSrv,

                                   "setTaskList",

                                   Q_ARG(QList<TsTaskChange>, changeDataSetMove1(1,2))));

    QCOMPARE(mModel->rowCount(), 5);    

    QCOMPARE(changeDataSet5New()[2].second->name(), mModel->data(mModel->index(2), Qt::DisplayRole).toString());

    QCOMPARE(changeDataSet5New()[3].second->name(), mModel->data(mModel->index(1), Qt::DisplayRole).toString());   

}

void T_TsModel::testFullUpdateFromActivities()

{

    QVERIFY(mModel);

    QVERIFY(activityService());

    clearModel();

    QList<QVariantHash> activity(activityDataSet(5));

    //provide test data to TestActivityManager

    QMetaObject::invokeMethod(activityService(),

                              "setActivitiesList",

                              Q_ARG(QList<QVariantHash>, activity));

    QMetaObject::invokeMethod(activityService(),

                              "emitDataChanged");   

    QCOMPARE(mModel->rowCount(), 5); 

}

//QTEST CALLBACKS

void T_TsModel::initTestCase()

{

    mAppSrv = new MockTsTaskMonitor();

    mActSrv = new AfManager();

    QVERIFY(mAppSrv);

    QVERIFY(mActSrv);

    mModel = new TsModel(*mAppSrv, *mActSrv);

    QVERIFY(mModel);

}

void T_TsModel::cleanupTestCase()

{

    delete mModel;

    mModel = 0;

    delete mActSrv;

    mActSrv = 0;

    QtMobility::QServiceManager manager;

    manager.removeService(serviceName);

    delete mAppSrv;

}

// HELPER FUNCTIONS

QObject *T_TsModel::activityService()

{

    return mActSrv;

}

QList<QVariantHash> T_TsModel::activityDataSet(int setId)const

{

    if (setId >100) {

        setId = 0;

    }

    QList<QVariantHash> retVal;

    QVariantHash node;

    int visibility = 0;

    for (int i =0; i < setId; ++i) {

        //valid node

        node.clear();

        node.insert(ActivityApplicationKeyword, i+120);

        node.insert(ActivityActivityKeyword, QString("testactivity%1").arg(i+120));

        node.insert(ActivityIconKeyword, QString());

        switch (visibility++) {

            case 0://visible

                node.insert(ActivityVisibleKeyword, true);

                break;

            case 1://invisible

                node.insert(ActivityVisibleKeyword, false);

                break;

            default://empty

                break;

        };

        if (2 < visibility) {

            visibility = 0;

        }

        retVal.append(node);

    }

    return retVal;

}

QList<TsTaskChange> T_TsModel::appDataSetFull(int setId)

{

    if (setId >100) {

        setId = 0;

    }

    QList<TsTaskChange> retVal;

    TsTaskChangeInfo qtChangeItem(-2, -2);

    retVal.append(TsTaskChange(qtChangeItem, QSharedPointer<TsTask>()));

    for (int iter(0); iter < setId; ++iter) {

        //valid node

        qtChangeItem = TsTaskChangeInfo(iter, TsTaskChangeInfo::KInvalidOffset);

        QSharedPointer<TsTask> node(new TsTask(new TsTaskContent(QString("testapplication%1").arg(iter), iter % 2, iter % 3), *this));

        retVal.append(TsTaskChange(qtChangeItem, node));

    }

    return retVal;

}

QList<TsTaskChange> T_TsModel::changeDataSet5New()

{

    QList<TsTaskChange> retVal;

    TsTaskChangeInfo qtChangeItem = TsTaskChangeInfo();

    // 1 cancel item at start of full update

    retVal.append(TsTaskChange(qtChangeItem, QSharedPointer<TsTask>()));

    // now 5 new items and changesetitem set to insert

    for (int iter(0); iter < 5; iter++) {

        qtChangeItem = TsTaskChangeInfo(iter, TsTaskChangeInfo::KInvalidOffset);

        QSharedPointer<TsTask> node(new TsTask(new TsTaskContent(QString("test %1").arg(iter+1), true, true), *this));

        retVal.append(TsTaskChange(qtChangeItem, node));

    }

    return retVal;

}

QList<TsTaskChange> T_TsModel::changeDataSetDelete1(int index)

{

    QList<TsTaskChange> retVal;

    TsTaskChangeInfo qtChangeItem(TsTaskChangeInfo::KInvalidOffset, index);    

    retVal.append(TsTaskChange(qtChangeItem, QSharedPointer<TsTask>()));

    return retVal;

}

QList<TsTaskChange> T_TsModel::changeDataSetInsert1(int index)

{

    QList<TsTaskChange> retVal;

    TsTaskChangeInfo qtChangeItem(index, TsTaskChangeInfo::KInvalidOffset);    

    QSharedPointer<TsTask> node(new TsTask(new TsTaskContent(QString("inserted %1").arg(index+1), true, true), *this));

    retVal.append(TsTaskChange(qtChangeItem, node));

    return retVal;    

}

QList<TsTaskChange> T_TsModel::changeDataSetChange1(int index)

{

    QList<TsTaskChange> retVal;

    TsTaskChangeInfo qtChangeItem(index, index);    

    QSharedPointer<TsTask> node(new TsTask(new TsTaskContent(QString("changed %1").arg(index+1), true, true), *this));

    retVal.append(TsTaskChange(qtChangeItem, node));

    return retVal;   

}

QList<TsTaskChange> T_TsModel::changeDataSetMove1(int newIndex, int oldIndex)

{

    QList<TsTaskChange> retVal;

    TsTaskChangeInfo qtChangeItem(newIndex, oldIndex);   

    retVal.append(TsTaskChange(qtChangeItem, QSharedPointer<TsTask>()));

    return retVal;  

}

int T_TsModel::activityDataSetsCount()const

{

    return dataSetsCount;

}

void T_TsModel::clearModel()

{

    QMetaObject::invokeMethod(mAppSrv,

                              "clearTasks");

    QMetaObject::invokeMethod(activityService(),

                              "clearActivities"); 

    mModel->fullUpdate();

}

QTEST_MAIN(T_TsModel)