/*
* 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);    
}

void MeasureTest::save10actTimes()
{
    *mStream<<"save 10 act 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;
    User::After(2000000); //2s
    for(int i=0; i<times; i++) {
        Before();
        for (int i=0; i<10; i++) {
            
            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();
        trymeasure.append(iResult);
        
        QList<QVariantHash> activities;
        ok  = QMetaObject::invokeMethod(mActivityClient, "activities", Q_RETURN_ARG(QList<QVariantHash>, activities));    
    
        if (ok) {
            QString name;
            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;
                }
            }
        }
        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);    
    
}

void MeasureTest::getTimesActivityData()
{
    int times = 0;
    times = mTimesCombo->currentText().toInt();
    *mStream<<"get data Times\n";
    QList<int> trymeasure;
    
    QList<QVariantHash> activities;
    bool ok  = QMetaObject::invokeMethod(mActivityClient, "activities", Q_RETURN_ARG(QList<QVariantHash>, activities));
    User::After(2000000); //2s
    if (ok) {
        QString name;
        QVariant data;        
        for(int i=0; i<times; i++) {
            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();
            trymeasure.append(iResult);
            User::After(2000000); //2s
        }
    }
    mItemMessage.clear();
    mResultMessage.clear();

    if (!ok) {
        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);

}

int MeasureTest::average(const QList<int>& list)
{
    int count = list.count();
    int sum=0;
    for(int i=0; i<count; i++) {
        sum += list.at(i);
    }
    sum = (sum+0.5)/count;
    return sum;
}

int MeasureTest::writeResults(const QList<int>& list, int average)
{
    for(int i=0; i<list.count(); i++){
        *mStream<<"|  ";
        *mStream<<list.at(i);
        *mStream<<"  |\n";
    }
    *mStream<<"|  ";
    *mStream<<average;
    *mStream<<"  |\n";
}