/*

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

#include <afactivitystorage.h>

#include <afactivation.h>

#include "afstorageglobals.h"

#include <HbCheckBox>

#include <hblineedit.h>

#include <f32file.h>

QTM_USE_NAMESPACE

const int KDefaultTimes = 10;

const int KDefaultLoop = 10;

const int KDefaultSaveBytes = 10*1024;

const int KGet1Bytes = 10*1024;

const int KGet2Bytes = 100*1024;

const int KGet3Bytes = 1024*1024;

const int KDefaultRepeat = 3;

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

    mActionCounter(0)

{

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

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

    mStream = new QTextStream(mFile);

    QServiceManager serviceManager;

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

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

    if (!mActivityManager) {

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

        }

    mActivityStorage = new AfActivityStorage;

    mActivation = new AfActivation;

    mResultLabel = new HbLabel();

    mItemLabel = new HbLabel();

    mSaveOneButton = new HbPushButton("Save 1 in loop");

    mSaveMoreButton = new HbPushButton("Save 10 in loop");    

    mGetButton = new HbPushButton("Get in loop");

    mAllButton = new HbPushButton("All");

    mLayout  = new QGraphicsGridLayout();

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

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

    mLayout->addItem(mSaveOneButton, 2, 0, 1, 6);

    mLayout->addItem(mSaveMoreButton, 3, 0, 1, 6);

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

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

    setLayout(mLayout);

    connect(mSaveOneButton, SIGNAL(released()), this, SLOT(preClear()));    

    connect(mSaveMoreButton, SIGNAL(released()), this, SLOT(preClear()));

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

    connect(mAllButton, SIGNAL(released()), this, SLOT(preClear()));

    connect(mSaveOneButton, SIGNAL(released()), this, SLOT(saveOne()));    

    connect(mSaveMoreButton, SIGNAL(released()), this, SLOT(saveMore()));

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

    connect(mAllButton, SIGNAL(released()), this, SLOT(all()));

    connect(mSaveOneButton, SIGNAL(released()), this, SLOT(startTimer()));    

    connect(mSaveMoreButton, SIGNAL(released()), this, SLOT(startTimer()));

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

    connect(mAllButton, SIGNAL(released()), this, SLOT(startTimer()));

    mTimer = new QTimer(this);

    connect(mTimer, SIGNAL(timeout()), this, SLOT(timeout()));

}

MeasureTest::~MeasureTest()

{

    delete mFile;

    delete mStream;    

    delete mActivityManager;

    delete mActivityStorage;

    delete mActivation;

}

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;

}

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";

}

void MeasureTest::logError(const QString& mess)

{

    *mStream<<"*Fail: "<<mess<<" *\n";

    mStream->flush();

}

bool MeasureTest::saveBytes(int bytes)

{    

    delete mByteArray;

    mByteArray = NULL;

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

    QVariant variant;

    variant = *mByteArray;

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

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

    QVariantHash metadata;

    metadata.insert(ActivityScreenshotKeyword, screenshot);

    bool ok = false;

    QString name("0");

    ok = mActivityStorage->saveActivity(name, variant, metadata);

    return ok;

}

bool MeasureTest::deleteActivities()

{

    QStringList activities = mActivityStorage->allActivities();    

    QString name;    

    bool ok = true;

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

        ok = mActivityStorage->removeActivity(activities.at(i));        

        if (!ok) {

            break;

        }

    }        

    return ok;

}

bool MeasureTest::saveOneInLoop(int action)

{

    int bytes = KDefaultSaveBytes;

    delete mByteArray;

    mByteArray = NULL;

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

    QVariant variant;

    variant = *mByteArray;

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

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

    QVariantHash metadata;

    metadata.insert(ActivityScreenshotKeyword, screenshot);

    int times = KDefaultTimes;    

    bool ok = false;    

    QString name("0");

    ok = deleteActivities();

    if(!ok) {

        logError("Remove");

        return false;

    }

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

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

        Before();

        ok = mActivityStorage->saveActivity(name, variant, metadata);

        After();

        Result();

        if (!ok) {

              break;

          }

        mResultsList[action].append(iResult);

        ok = deleteActivities();

        if(!ok) {

            logError("Remove");

            return false;

        }

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

    }

    int averageint = average(mResultsList.at(action));

    mResultsList[action].append(averageint);

    if(!ok) {

        logError("SaveOne");        

    }

    return ok;

}

bool MeasureTest::saveMoreInLoop(int action)

{

    int bytes = KDefaultSaveBytes;

    delete mByteArray;

    mByteArray = NULL;

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

    QVariant variant;

    variant = *mByteArray;

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

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

    QVariantHash metadata;

    metadata.insert(ActivityScreenshotKeyword, screenshot);

    bool ok = deleteActivities();

    if(!ok) {

        logError("Remove");

        return false;

    }

    int times = KDefaultTimes;    

     ok = false;

     QString name;

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

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

         Before();

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

             name.setNum(i);

             ok = mActivityStorage->saveActivity(name, variant, metadata);

             if (!ok) {

                 break;

             }            

         }

         After();

         Result();

         mResultsList[action].append(iResult);

         QStringList activities = mActivityStorage->allActivities();      

         ok = deleteActivities();

         if(!ok) {

             logError("Remove");

             return false;

         }

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

     }       

     int averageint = average(mResultsList.at(action));

     averageint = (averageint+0.5)/KDefaultLoop;

     mResultsList[action].append(averageint);

     if(!ok) {

         logError("SaveMore");        

     }

     return ok;

}

bool MeasureTest::getOneInLoop(int bytes, int action)

{

    int times = KDefaultTimes;

    bool ok = deleteActivities();

    if(!ok) {

        logError("Remove");

        return false;

    }

    ok = saveBytes(bytes);

    if(!ok) {

        logError("SaveBytes");

        return false;

    }

     QStringList activities = mActivityStorage->allActivities();

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

     QString name;

     QVariant data;        

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

         Before();

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

             data = mActivityStorage->activityData(activities.at(i));

         }

         After();

         Result();

         mResultsList[action].append(iResult);

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

     }

     int averageint = average(mResultsList.at(action));

     mResultsList[action].append(averageint);

     if(!ok) {

         logError("GetOne");        

     }

     return ok;

}

void MeasureTest::saveOne()

{

    QList<int> l;

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

        mActionsList.append("save1");        

        mResultsList.append(l);

    }

}

void MeasureTest::saveMore()

{

    QList<int> l;

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

        mActionsList.append("save10");        

        mResultsList.append(l);

    }

}

void MeasureTest::getOne()

{

    QList<int> l;

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

        mActionsList.append("get1"); 

        mResultsList.append(l);

    }

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

        mActionsList.append("get2"); 

        mResultsList.append(l);

    }

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

        mActionsList.append("get3"); 

        mResultsList.append(l);

    }

}

void MeasureTest::all()

{

    saveOne();

    saveMore();

    getOne();

}

void MeasureTest::timeout()

{

    if(mActionCounter == mActionsList.count()) {

        mTimer->stop();

        logResult();

        enableControls(true);

        return;

    }

    QString actionName = mActionsList.at(mActionCounter);

    bool ok = false;

    if(actionName == "save1") {

        ok = saveOneInLoop(mActionCounter);

    }

    else if(actionName == "save10") {

        ok = saveMoreInLoop(mActionCounter);

    }

    else if(actionName == "get1") {

        ok = getOneInLoop(KGet1Bytes, mActionCounter);

    }

    else if(actionName == "get2") {

        ok = getOneInLoop(KGet2Bytes, mActionCounter);

    }

    else if(actionName == "get3") {

        ok = getOneInLoop(KGet3Bytes, mActionCounter);

    }

    else {

        ok = false;

    }

    mItemMessage.clear();

    mResultMessage.clear();

    mItemMessage = (tr("action: %1")).arg(actionName);

    mResultMessage = (tr("count: %1")).arg(mActionCounter).arg(ok);

    mItemLabel->setPlainText(mItemMessage);

    mResultLabel->setPlainText(mResultMessage); 

    mActionCounter++;

}

void MeasureTest::preClear()

{

    mResultsList.clear();

    mActionsList.clear();

    mActionCounter = 0;

    enableControls(false);

}

void MeasureTest::startTimer()

{

    mTimer->start(1);

}

void MeasureTest::logResult()

{

    QList<int> save1indexes;

    QList<int> save10indexes;

    QList<int> get1indexes;

    QList<int> get2indexes;

    QList<int> get3indexes;

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

        QString actionName = mActionsList.at(i);

        if(actionName == "save1") {

            save1indexes.append(i);

        }

        else if(actionName == "save10") {

            save10indexes.append(i);

        }

        else if(actionName == "get1") {

            get1indexes.append(i);

        }

        else if(actionName == "get2") {

            get2indexes.append(i);

        }

        else if(actionName == "get3") {

            get3indexes.append(i);

        }

    }

    logSaveSummary(save1indexes, save10indexes);

    logResult(save1indexes, 1, "Save one activity", "save");

    logResult(save10indexes, 2, "Save 10 activities in loop", "save");

    logGetSummary(get1indexes, get2indexes, get3indexes);

    logResult(get1indexes, 1, "Get activities with 10 KB of data", "get");

    logResult(get2indexes, 2, "Get activities with 100 KB of data", "get");

    logResult(get3indexes, 3, "Get activities with 1 MB of data", "get");

}

void MeasureTest::logResult(const QList<int>& indexes, int caseno, const QString& mess, const QString& type)

{

    int indexno = indexes.count();

    if(indexno == 0) {

        return;

    }

    QString caseness = tr("---+++++ Case %1.\n\n").arg(caseno);

    *mStream<<caseness;

    *mStream<<mess<<"\n\n";

    *mStream<<"|    |";

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

        QString mess = tr("  *Test %1 [ms]*  |").arg(i);

        *mStream<<mess;

    }

    *mStream<<"\n";

    QString tempmess;

    for(int i=0; i<KDefaultTimes+1; i++) {