/*

* 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 "hbmeasuretest.h"

#include <QGridLayout>

#include <HbLabel>

#include <HbPushButton>

#include <QCoreApplication>

#include <QSignalMapper>

#include <QVariant>

#include <QList>

#include <QVariantHash>

#include <HbComboBox>

#include <QBrush>

#include <QPalette>

#include <QGraphicsGridLayout>

#include <QTimer>

#include <QFile>

#include <QTextStream>

#include <e32std.h>

#include <HbInstance>

#include <qservicemanager.h>

#include <HbScrollArea>

const char ActivityApplicationKeyword [] = ":ApplicationId";

const char ActivityActivityKeyword [] = ":ActivityName";

const char ActivityScreenshotKeyword [] = "screenshot";

QTM_USE_NAMESPACE

MeasureTest::MeasureTest(QGraphicsItem *parent) : HbView(parent), mActivityClient(NULL), mByteArray(NULL)

{

    mFile = new QFile("c:\\measuretest.txt");    

    mFile->open(QIODevice::Append | QIODevice::Text);

    mStream = new QTextStream(mFile);

    mThumbwait = 0;

    mThumbnull = 0;

    mThumbcurrent = 0;

    QServiceManager serviceManager;

    serviceManager.addService(":/activityserviceplugin.xml");

    mActivityClient = serviceManager.loadInterface("com.nokia.qt.activities.ActivityClient");

    if (!mActivityClient) {

        qFatal("Cannot initialize critical com.nokia.qt.activities.ActivityClient service.");

    }

    mActivityManager = serviceManager.loadInterface("com.nokia.qt.activities.ActivityManager");

    if (!mActivityManager) {

        qFatal("Cannot initialize critical com.nokia.qt.activities.ActivityManager service.");

    }

    HbWidget* widget = new HbWidget;

    HbScrollArea* scrollArea = new HbScrollArea; 

    mResultLabel = new HbLabel();

    mItemLabel = new HbLabel();

    mTimesLabel = new HbLabel("Times");

    mBytesLabel = new HbLabel("Bytes");

    mPixmapLabel = new HbLabel("Pixmap");  	  

    mSizeLabel = new HbLabel("Size(WxH)");

    mPixmap = new QPixmap(":/images/wolf.bmp");

    mEmptyPixmap = new QPixmap();

    mTimesCombo = new HbComboBox();

    mLengthCombo = new HbComboBox();

    mPixmapCombo = new HbComboBox();

    mWidthCombo = new HbComboBox();

    mHeightCombo = new HbComboBox();

    mTimesCombo->addItem("1");

    mTimesCombo->addItem("2");	

    mTimesCombo->addItem("4");

    mTimesCombo->addItem("5");

    mTimesCombo->addItem("10");

    mTimesCombo->addItem("20");

    mTimesCombo->addItem("40");

    mTimesCombo->addItem("60");

    QVariant variant;

    variant = 10;

    mLengthCombo->addItem("10 B", variant);

    variant = 100;

    mLengthCombo->addItem("100 B", variant);

    variant = 1024;

    mLengthCombo->addItem("1 KB", variant);

    variant = 10240;

    mLengthCombo->addItem("10 KB", variant);

    variant = 102400;

    mLengthCombo->addItem("100 KB", variant);

    variant = 1024*1024;

    mLengthCombo->addItem("1 MB", variant);

    mWidthCombo->addItem("360");

    mWidthCombo->addItem("180");

    mWidthCombo->addItem("128");

    mWidthCombo->addItem("90");

    mHeightCombo->addItem("640");

    mHeightCombo->addItem("320");

    mHeightCombo->addItem("160");

    mHeightCombo->addItem("128");

    mPixmapCombo->addItem("no");

    mPixmapCombo->addItem("yes");

    mPixmapCombo->addItem("grab");

    mSaveButton = new HbPushButton("Add activities");

    mGetButton = new HbPushButton("Get activities");

    mDelButton = new HbPushButton("Delete activities");

    mGetDataButton = new HbPushButton("Get activities data");

    mUpdateButton = new HbPushButton("Update activities");

    mThumbButton = new HbPushButton("Get act with thumb");

    mGetDataTimesButton = new HbPushButton("Get data times");

    mSaveTimesButton = new HbPushButton("Add act times");

    mSave10TimesButton = new HbPushButton("Add 10 act times");;

    mLayout  = new QGraphicsGridLayout();

    mLayout->addItem(mResultLabel, 0, 0, 1, 6);

    mLayout->addItem(mItemLabel, 1, 0, 1, 6);

    mLayout->addItem(mSizeLabel, 2, 0, 1, 2);

    mLayout->addItem(mWidthCombo, 2, 2, 1, 2);

    mLayout->addItem(mHeightCombo, 2, 4, 1, 2);

    mLayout->addItem(mTimesLabel, 3, 0, 1, 2);

    mLayout->addItem(mBytesLabel, 3, 2, 1, 2);

    mLayout->addItem(mPixmapLabel, 3, 4, 1, 2);

    mLayout->addItem(mTimesCombo, 4, 0, 1, 2);

    mLayout->addItem(mLengthCombo, 4, 2, 1, 2);

    mLayout->addItem(mPixmapCombo, 4, 4, 1, 2);

    mLayout->addItem(mSaveButton, 5, 0, 1, 6);

    mLayout->addItem(mGetButton, 6, 0, 1, 6);

    mLayout->addItem(mDelButton, 7, 0, 1, 6);

    mLayout->addItem(mGetDataButton, 8, 0, 1, 6);

    mLayout->addItem(mUpdateButton, 9, 0, 1, 6);

    mLayout->addItem(mThumbButton, 10, 0, 1, 6);    

    mLayout->addItem(mSaveTimesButton, 11, 0, 1, 6);

    mLayout->addItem(mSave10TimesButton, 12, 0, 1, 6);

    mLayout->addItem(mGetDataTimesButton, 13, 0, 1, 6);

    widget->setLayout(mLayout);

    scrollArea->setContentWidget(widget);

    scrollArea->setScrollDirections(Qt::Vertical);

    scrollArea->setVerticalScrollBarPolicy(HbScrollArea::ScrollBarAlwaysOff);

    connect(mSaveButton, SIGNAL(released()), this, SLOT(saveActivity()));

    connect(mGetButton, SIGNAL(released()), this, SLOT(getActivity()));

    connect(mDelButton, SIGNAL(released()), this, SLOT(deleteActivity()));

    connect(mGetDataButton, SIGNAL(released()), this, SLOT(getActivityData()));

    connect(mUpdateButton, SIGNAL(released()), this, SLOT(updateActivity()));

    connect(mThumbButton, SIGNAL(released()), this, SLOT(getActivityThumb()));

    connect(mGetDataTimesButton, SIGNAL(released()), this, SLOT(getTimesActivityData()));

    connect(mSaveTimesButton, SIGNAL(released()), this, SLOT(saveTimes()));

    connect(mSave10TimesButton, SIGNAL(released()), this, SLOT(save10actTimes()));

    QGraphicsGridLayout* mainLayout = new QGraphicsGridLayout;

    mainLayout->addItem(scrollArea, 0, 0, 1, 6);    

    setLayout(mainLayout);

}

MeasureTest::~MeasureTest()

{

    delete mFile;

    delete mEmptyPixmap;

    delete mPixmap;

    delete mActivityClient;

    delete mActivityManager;

}

void MeasureTest::Before()

{

    TTime time;

    time.HomeTime();

    iBefore = time.Int64();

}

void MeasureTest::After()

{

    TTime time;

    time.HomeTime();

    iAfter = time.Int64();

}

void MeasureTest::Result()

{

    TInt64 res(0);

    res = iAfter-iBefore;

    res = res/1000;

    iResult = res;

}

void  MeasureTest::deleteActivity()

{

    QList<QVariantHash> activities;

    bool ok  = QMetaObject::invokeMethod(mActivityClient, "activities", Q_RETURN_ARG(QList<QVariantHash>, activities));

    bool retok = false;

    if (ok) {

        QString name;

        Before();

        for (int i=0; i<activities.count(); i++) {

            name = activities.at(i).value(":ActivityName").toString();

            ok = QMetaObject::invokeMethod(mActivityClient, "removeActivity", Q_RETURN_ARG(bool, retok), Q_ARG(QString, name));

            if (!ok || !retok) {

                break;

            }

        }

        After();

        Result();

    }

    mItemMessage.clear();

    mResultMessage.clear();

    if (!ok || !retok) {

        mItemMessage = (tr("invoke error"));

        mResultMessage = (tr("invoke error"));

    } else {

        mItemMessage = (tr("items: %1")).arg(activities.count());

        mResultMessage = (tr("time: %1 ms")).arg(iResult);

    }

    mItemLabel->setPlainText(mItemMessage);

    mResultLabel->setPlainText(mResultMessage);

}

void  MeasureTest::getActivity()

{

    bool ok = false;

    QList<QVariantHash> activities;

    Before();

    ok = QMetaObject::invokeMethod(mActivityClient, "activities", Q_RETURN_ARG(QList<QVariantHash>, activities));

    After();

    Result();

    int count = activities.count();

    mItemMessage.clear();

    mResultMessage.clear();

    if (!ok) {

        mItemMessage = (tr("invoke error"));

        mResultMessage = (tr("invoke error"));

    } else {

        mItemMessage = (tr("items: %1")).arg(count);

        mResultMessage = (tr("time: %1 ms")).arg(iResult);

    }

    mItemLabel->setPlainText(mItemMessage);

    mResultLabel->setPlainText(mResultMessage);

}

void  MeasureTest::getActivityThumb()

{

    disconnect( mActivityManager, SIGNAL(thumbnailReady(QPixmap, void *)), this, SLOT(thumbnailReady(QPixmap, void *)) );

    connect( mActivityManager, SIGNAL(thumbnailReady(QPixmap, void *)), this, SLOT(thumbnailReady(QPixmap, void *)) );

    mThumbwait = 0;

    mThumbnull = 0;

    mThumbcurrent = 0;

    bool ok = false;

    QList<QVariantHash> activities;

    Before();

    ok = QMetaObject::invokeMethod(mActivityClient, "activities", Q_RETURN_ARG(QList<QVariantHash>, activities));

    mThumbwait = activities.count();

        int width = mWidthCombo->currentText().toInt();

        int height = mHeightCombo->currentText().toInt();

        QSize pixSize(width, height);

    for ( int i=0; i<activities.count(); i++)

        {

        //QString app = activities.at(i).value(ActivityApplicationKeyword);

        //QString act = activities.at(i).value(ActivityActivityKeyword);

        QString pixfile = activities.at(i).value(ActivityScreenshotKeyword).toString();

        ok = QMetaObject::invokeMethod(mActivityManager, "getThumbnail", Q_ARG(QSize, pixSize), Q_ARG(QString, pixfile), Q_ARG(void*, NULL));        

        if ( !ok )

            {

            break;

            }        

        }

    int count = activities.count();

    mItemMessage.clear();

    mResultMessage.clear();

    if (!ok) {

        mItemMessage = (tr("invoke error"));

        mResultMessage = (tr("invoke error"));

        mItemLabel->setPlainText(mItemMessage);

        mResultLabel->setPlainText(mResultMessage);

    } else {

        //connect( mActivityManager, SIGNAL(thumbnailReady(QPixmap, void *)), this, SLOT(thumbnailReady(QPixmap, void *)) );

    }

}

void MeasureTest::saveActivity()

{

    int bytes = mLengthCombo->itemData(mLengthCombo->currentIndex()).toInt();

    delete mByteArray;

    mByteArray = NULL;

    mByteArray = new QByteArray(bytes, 'a');

    QVariant variant;

    variant = *mByteArray;

    QPixmap *pixmap = NULL;

    QPixmap screenshot;

    if (mPixmapCombo->currentText() == "yes") {

        pixmap = mPixmap;

    }

    else if ( mPixmapCombo->currentText() == "grab" )

    {

        HbMainWindow *mainWindow = hbInstance->allMainWindows().first();

        screenshot = QPixmap::grabWidget(mainWindow, mainWindow->rect());

        pixmap = &screenshot;

    }

    else

    {

        pixmap = mEmptyPixmap;

    }

    QVariantHash metadata;

    metadata.insert("screenshot", *pixmap);

    int times = 0;

    times = mTimesCombo->currentText().toInt();

    bool ok = false;

    bool retok = false;

    Before();

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

        QString name;

        name.setNum(i);

        ok = QMetaObject::invokeMethod(mActivityClient, "addActivity", Q_RETURN_ARG(bool, retok), Q_ARG(QString, name), Q_ARG(QVariant, variant), Q_ARG(QVariantHash, metadata));

        if (!ok || !retok) {

            break;

        }

    }

    After();

    Result();

    mItemMessage.clear();

    mResultMessage.clear();

    if (!ok || !retok) {

        mItemMessage = (tr("invoke error"));

        mResultMessage = (tr("invoke error"));

    } else {

        mResultMessage = (tr("time: %1 ms")).arg(iResult);

    }

    mItemLabel->setPlainText(mItemMessage);

    mResultLabel->setPlainText(mResultMessage);

}

void MeasureTest::updateActivity()

{

    int bytes = mLengthCombo->itemData(mLengthCombo->currentIndex()).toInt();

    delete mByteArray;

    mByteArray = NULL;

    mByteArray = new QByteArray(bytes, 'a');

    QVariant variant;

    variant = *mByteArray;

    QPixmap *pixmap = NULL;

    QPixmap screenshot;

    if (mPixmapCombo->currentText() == "yes") {

        pixmap = mPixmap;

    }

    else if ( mPixmapCombo->currentText() == "grab" )

    {

        HbMainWindow *mainWindow = hbInstance->allMainWindows().first();

        screenshot = QPixmap::grabWidget(mainWindow, mainWindow->rect());

        pixmap = &screenshot;

    }

    else

    {

        pixmap = mEmptyPixmap;

    }

    QVariantHash metadata;

    metadata.insert("screenshot", *pixmap);

    int times = 0;

    times = mTimesCombo->currentText().toInt();

    bool ok = false;

    bool retok = false;

    Before();

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

        QString name;

        name.setNum(i);

        ok = QMetaObject::invokeMethod(mActivityClient, "updateActivity", Q_RETURN_ARG(bool, retok), Q_ARG(QString, name), Q_ARG(QVariant, variant), Q_ARG(QVariantHash, metadata));

        if (!ok || !retok) {

            break;

        }

    }

    After();

    Result();

    mItemMessage.clear();

    mResultMessage.clear();

    if (!ok || !retok) {

        mItemMessage = (tr("invoke error"));

        mResultMessage = (tr("invoke error"));

    } else {

        mResultMessage = (tr("time: %1 ms")).arg(iResult);

    }

    mItemLabel->setPlainText(mItemMessage);

    mResultLabel->setPlainText(mResultMessage);

}

void MeasureTest::getActivityData()

{

    QList<QVariantHash> activities;

    bool ok  = QMetaObject::invokeMethod(mActivityClient, "activities", Q_RETURN_ARG(QList<QVariantHash>, activities));

    if (ok) {

        QString name;

        QVariant data;

        Before();

        for (int i=0; i<activities.count(); i++) {

            name = activities.at(i).value(":ActivityName").toString();

            ok = QMetaObject::invokeMethod(mActivityClient, "activityData", Q_RETURN_ARG(QVariant, data), Q_ARG(QString, name));

            if (!ok) {

                break;

            }

        }

        After();

        Result();

    }

    mItemMessage.clear();

    mResultMessage.clear();

    if (!ok) {

        mItemMessage = (tr("invoke error"));

        mResultMessage = (tr("invoke error"));

    } else {

        mItemMessage = (tr("items: %1")).arg(activities.count());

        mResultMessage = (tr("time: %1 ms")).arg(iResult);

    }

    mItemLabel->setPlainText(mItemMessage);

    mResultLabel->setPlainText(mResultMessage);

}

void MeasureTest::thumbnailReady(QPixmap pix, void * ptr)

    {

    if ( pix.isNull() )

        {

        mThumbnull++;

        }    

    mThumbcurrent++;

    mItemMessage = (tr("items: %1 from %2, but null %3")).arg(mThumbcurrent).arg(mThumbwait).arg(mThumbnull);

    mItemLabel->setPlainText(mItemMessage);

    mResultMessage = "";

    mResultLabel->setPlainText(mResultMessage);

    if (mThumbcurrent == mThumbwait)

        {

        After();

        Result();

        disconnect( mActivityManager, SIGNAL(thumbnailReady(QPixmap, void *)), this, SLOT(thumbnailReady(QPixmap, void *)) );

        mResultMessage = (tr("time: %1 ms")).arg(iResult);

        mResultLabel->setPlainText(mResultMessage);

        }

    }

void MeasureTest::saveTimes()

{

    *mStream<<"save Times\n";

    QList<int> trymeasure;

    int bytes = mLengthCombo->itemData(mLengthCombo->currentIndex()).toInt();

    delete mByteArray;

    mByteArray = NULL;

    mByteArray = new QByteArray(bytes, 'a');

    QVariant variant;

    variant = *mByteArray;

    QPixmap *pixmap = NULL;

    QPixmap screenshot;

    if (mPixmapCombo->currentText() == "yes") {

        pixmap = mPixmap;

    }

    else if ( mPixmapCombo->currentText() == "grab" )

    {

        HbMainWindow *mainWindow = hbInstance->allMainWindows().first();

        screenshot = QPixmap::grabWidget(mainWindow, mainWindow->rect());

        pixmap = &screenshot;

    }

    else

    {

        pixmap = mEmptyPixmap;

    }

    QVariantHash metadata;

    metadata.insert("screenshot", *pixmap);

    int times = 0;

    times = mTimesCombo->currentText().toInt();

    bool ok = false;

    bool retok = false;

    QString name("0");

    User::After(2000000); //2s

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

        Before();

        ok = QMetaObject::invokeMethod(mActivityClient, "addActivity", Q_RETURN_ARG(bool, retok), Q_ARG(QString, name), Q_ARG(QVariant, variant), Q_ARG(QVariantHash, metadata));

        After();

        Result();

        if (!ok || !retok) {

              break;

          }

        trymeasure.append(iResult);

        ok = QMetaObject::invokeMethod(mActivityClient, "removeActivity", Q_RETURN_ARG(bool, retok), Q_ARG(QString, name));        

        if (!ok || !retok) {

            break;

        }

        User::After(2000000); //2s

    }

    mItemMessage.clear();

    mResultMessage.clear();

    if (!ok || !retok) {

        mItemMessage = (tr("invoke error"));

        mResultMessage = (tr("invoke error"));

        *mStream<<"error\n";

    } else {

        int averageint = average(trymeasure);

        mResultMessage = (tr("time: %1 ms")).arg(averageint);

        writeResults(trymeasure, averageint);

    }

    mStream->flush();

    mItemLabel->setPlainText(mItemMessage);

    mResultLabel->setPlainText(mResultMessage);    

}