/****************************************************************************

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the examples of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the either Technology Preview License Agreement or the

** Beta Release License Agreement.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain

** additional rights. These rights are described in the Nokia Qt LGPL

** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this

** package.

**

** GNU General Public License Usage

** Alternatively, this file may be used under the terms of the GNU

** General Public License version 3.0 as published by the Free Software

** Foundation and appearing in the file LICENSE.GPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU General Public License version 3.0 requirements will be

** met: http://www.gnu.org/copyleft/gpl.html.

**

** If you are unsure which license is appropriate for your use, please

** contact the sales department at http://qt.nokia.com/contact.

** $QT_END_LICENSE$

**

****************************************************************************/

#include <QDebug>

#include <QMutex>

#include <QWaitCondition>

#include <QApplication>

#include <QDir>

#include <QPluginLoader>

#include "testcontroller.h"

#include "itemrecyclinglist.h"

#include "simplelist.h"

#include "scrollbar.h"

#include "mainview.h"

#include "theme.h"

#include "themeevent.h"

#include "filllists.h"

static const int EmitDoneTimeout = 1000;

Q_DECLARE_METATYPE(TestController*)

TestController::TestController(const QString &fname, MainView *mv, ResultLogger::ResultFormat format, QObject *parent)

    : QObject(parent),

    mMainView(mv),

    mCurrentSimpleList(0),

    mCurrentRecyclingList(0),

    mTestDuration(),

    mMaxTestDurationTime(0),

    mScrollDirection(1),

    mFileName(fname),

    mResultFormat(format),

    mDataGenerator(),

    mResMon(0),

    mSubtreeCacheEnabled(false),

    mScrollStep(36),

    mCpuMemLogging(true),

    mLastElapsed(0)

{

    qRegisterMetaType<TestController*>();    

    connect(QApplication::instance(), SIGNAL(aboutToQuit()), this, SLOT(aboutToQuit()));

    if(loadPlugin()) {

        //qDebug() << "Loaded plugin!";

        if (mResMon->Prepare("tst_GraphicsViewBenchmark")) {

        }

    }

    else {

        qDebug() << "Failed to load plugin!";

    }

}

TestController::~TestController()

{

    delete mResMon;

}

void TestController::printResourceLoad()

{

#if defined Q_OS_LINUX

    if (mResMon) {

        ResourceMonitorInterface::CpuUsage usage = mResMon->CPULoad();

        ResourceMonitorInterface::MemoryAllocation allocation = mResMon->MemoryLoad();

        qDebug() << "CPULoad: total" << usage.systemUsage << "(%), app" << usage.appTreadUsage << "(%)";

        qDebug() << "MemoryLoad: occupied by app chunks" << allocation.allocatedInAppThread << "(bytes), number of free app chunks" << allocation.numberOfAllocatedCellsInAppThread << ", avaliable in app heap" << allocation.availableMemoryInAppThreadHeap <<"(bytes), total memory" << allocation.totalMemoryInSystem << "(bytes), free memory" << allocation.availableMemoryInSystem << "(bytes)";

    }

#endif

}

QString TestController::resultFileName()

{

    return mFileName;

}

ResultLogger::ResultFormat TestController::resultFileFormat()

{

    return mResultFormat;

}

void TestController::setSubtreeCache(const bool enabled)

{

    mSubtreeCacheEnabled = enabled;

}

bool TestController::subtreeCache() const

{

    return mSubtreeCacheEnabled;

}

void TestController::setScrollStep(const int step)

{

    mScrollStep = step;

}

int TestController::scrollStep() const

{

    return mScrollStep;

}

void TestController::rotateMainWindow(const int angle)

{

    if (mMainView)

        mMainView->rotateContent(angle);

    QTimer::singleShot(EmitDoneTimeout, this, SLOT(testIsDone()));

}

int TestController::mainWindowRotationAngle() const

{

    if (mMainView)

        return mMainView->rotationAngle();

    return 0;

}

void TestController::setCpuMemLogging(const bool enabled)

{

    mCpuMemLogging = enabled;

}

void TestController::aboutToQuit()

{

    testIsDone();

    emit stop();

}

void TestController::changeTheme(Theme::Themes theme)

{

    Theme::p()->setTheme(theme);

}

void TestController::testIsDone()

{

    mScrollDirection = 1;    

    mCurrentRecyclingList = 0;

    mCurrentSimpleList = 0;

    mMaxTestDurationTime = 0;

    if (mMainView)

        mMainView->fpsReset();

    emit testDone();

}

void TestController::fillList(int itemCount, Benchmark::ListType listType,

                              TestFunctionResult *testFunctionResult,  const QString &tag)

{

    if (!mMainView) {

        QTimer::singleShot(EmitDoneTimeout, this, SLOT(testIsDone()));

        return;

    }

    Benchmark *b = testFunctionResult->createBenchmark();

    b->setRotation(mainWindowRotationAngle());

    b->setListSize(itemCount);

    b->setUseListItemCache(mSubtreeCacheEnabled);

    b->setImageBasedRendering(mMainView->imageBasedRendering());

    b->setTheme(Theme::p()->currentThemeName());

    b->setListType(listType);

    b->setTag(tag);

    if (listType==Benchmark::RecyclingListType){

        if(mResMon && mCpuMemLogging) {

            //CPU/MEM begin

            mResMon->BeginMeasureCPULoad(); 

            mResMon->BeginMeasureMemoryLoad();

        }

        QTime t;

        t.start();

        ItemRecyclingList *list = new ItemRecyclingList();

        list->setListItemCaching(mSubtreeCacheEnabled);

        mMainView->setTestWidget(list);

        mDataGenerator.Reset();

        fillRecyclingList(mDataGenerator, itemCount, list);

        int took = t.elapsed();

        b->setValue(took);

        if(mResMon && mCpuMemLogging) {

            //CPU/MEM end

            createCpuBenchmark(testFunctionResult, tag, itemCount, listType,Theme::p()->currentThemeName(), mResMon->EndMeasureCPULoad());

            createMemoryBenchmark(testFunctionResult, tag, itemCount, listType,Theme::p()->currentThemeName(), mResMon->EndMeasureMemoryLoad());

        }

    }

    else {

        if(mResMon && mCpuMemLogging) {

            //CPU/MEM begin

            mResMon->BeginMeasureCPULoad(); 

            mResMon->BeginMeasureMemoryLoad();

        }

        QTime t;

        t.start();

        SimpleList *list = new SimpleList();

        list->setListItemCaching(mSubtreeCacheEnabled);

        mMainView->setTestWidget(list);

        mDataGenerator.Reset();

        fillSimpleList(mDataGenerator, itemCount, list);

        int took = t.elapsed();

        b->setValue(took);

        if(mResMon && mCpuMemLogging) {

            //CPU/MEM end

            createCpuBenchmark(testFunctionResult, tag, itemCount, listType,Theme::p()->currentThemeName(), mResMon->EndMeasureCPULoad());

            createMemoryBenchmark(testFunctionResult, tag, itemCount, listType,Theme::p()->currentThemeName(), mResMon->EndMeasureMemoryLoad());

        }

    }

    // Make sure we record the correct view size

    b->setWidth(mMainView->size().width());

    b->setHeight(mMainView->size().height());

    QTimer::singleShot(EmitDoneTimeout, this, SLOT(testIsDone()));

}

void TestController::scrollList(int maxTimeMs, TestFunctionResult *testFunctionResult, const QString &tag)

{

    if (!mMainView) {

        QTimer::singleShot(EmitDoneTimeout, this, SLOT(testIsDone()));

        return;

    }

    mMaxTestDurationTime = maxTimeMs;

    QGraphicsWidget *tw = mMainView->testWidget();

    ItemRecyclingList *list = dynamic_cast<ItemRecyclingList *>(tw);    

    if (list) {

        if (mMainView)

            mMainView->fpsReset();

        mTestDuration.start();

        mLastElapsed = 0;

        mCurrentRecyclingList = list;

        connect(this, SIGNAL(doScrollRecyclingList(TestFunctionResult*, const QString &)),

                this, SLOT(scrollRecyclingList(TestFunctionResult*, const QString &)), Qt::QueuedConnection);

        if(mResMon && mCpuMemLogging) {

            //CPU/MEM begin

            mResMon->BeginMeasureCPULoad(); 

            mResMon->BeginMeasureMemoryLoad();

        }

        emit doScrollRecyclingList(testFunctionResult, tag);

    }

    else {

        SimpleList *list = dynamic_cast<SimpleList*>(tw);

        if (list) {

            if (mMainView)

                mMainView->fpsReset();

            mTestDuration.start();

            mLastElapsed = 0;

            mCurrentSimpleList = list;

            connect(this, SIGNAL(doScrollSimpleList(TestFunctionResult*, const QString &)),

                    this, SLOT(scrollSimpleList(TestFunctionResult*, const QString &)), Qt::QueuedConnection);

            if(mResMon && mCpuMemLogging) {

                //CPU/MEM begin        

                mResMon->BeginMeasureCPULoad(); 

                mResMon->BeginMeasureMemoryLoad();

            }

            emit doScrollSimpleList(testFunctionResult, tag);

        }

        else {

            QTimer::singleShot(EmitDoneTimeout, this, SLOT(testIsDone()));

        }

   }

}

void TestController::addToBeginningOfList(int itemCount, TestFunctionResult *testFunctionResult, const QString &tag)

{

    if (!mMainView) {

        QTimer::singleShot(EmitDoneTimeout, this, SLOT(testIsDone()));

        return;

    }

    Benchmark *b = testFunctionResult->createBenchmark();

    b->setTag(tag);

    b->setRotation(mainWindowRotationAngle());

    b->setListSize(itemCount);

    b->setUseListItemCache(mSubtreeCacheEnabled);

    b->setImageBasedRendering(mMainView->imageBasedRendering());

    b->setTheme(Theme::p()->currentThemeName());

    b->setWidth(mMainView->size().width());

    b->setHeight(mMainView->size().height());

    QGraphicsWidget *tw = mMainView->testWidget();

    ItemRecyclingList *list = dynamic_cast<ItemRecyclingList *>(tw);

    if (list) {

        QString type = list->objectName();

        if(mResMon && mCpuMemLogging) {

            //CPU/MEM begin

            mResMon->BeginMeasureCPULoad(); 

            mResMon->BeginMeasureMemoryLoad();

        }

        QTime t;

        t.start();

        for (int i=0; i<itemCount; ++i )

            list->insertItem(0, newRecyclingListItem(mDataGenerator, i));

        int took = t.elapsed();

        if(mResMon && mCpuMemLogging) {

            //CPU/MEM end

            createCpuBenchmark(testFunctionResult, tag, itemCount, Benchmark::RecyclingListType,Theme::p()->currentThemeName(), mResMon->EndMeasureCPULoad());

            createMemoryBenchmark(testFunctionResult, tag, itemCount, Benchmark::RecyclingListType,Theme::p()->currentThemeName(), mResMon->EndMeasureMemoryLoad());

        }

        b->setValue(took);

        b->setListType(Benchmark::RecyclingListType);

    }

    else {

        SimpleList *list = dynamic_cast<SimpleList*>(tw);

        if (list) {

            QString type = list->objectName();

            if(mResMon && mCpuMemLogging) {

                //CPU/MEM begin

                mResMon->BeginMeasureCPULoad(); 

                mResMon->BeginMeasureMemoryLoad();

            }

            QTime t;

            t.start();

            for (int i=0; i<itemCount; ++i )

                list->insertItem(0,newSimpleListItem(mDataGenerator, i));

            int took = t.elapsed();

            if(mResMon && mCpuMemLogging) {

                //CPU/MEM end

                createCpuBenchmark(testFunctionResult, tag, itemCount, Benchmark::SimpleListType, Theme::p()->currentThemeName(), mResMon->EndMeasureCPULoad());

                createMemoryBenchmark(testFunctionResult, tag, itemCount, Benchmark::SimpleListType, Theme::p()->currentThemeName(), mResMon->EndMeasureMemoryLoad());

            }

            b->setValue(took);

            b->setListType(Benchmark::SimpleListType);

        }

   }

   QTimer::singleShot(EmitDoneTimeout, this, SLOT(testIsDone()));

}

void TestController::removeFromBeginningOfList(int itemCount, TestFunctionResult *testFunctionResult, const QString &tag)

{

    if (!mMainView) {

        QTimer::singleShot(EmitDoneTimeout, this, SLOT(testIsDone()));

        return;

    }

    Benchmark *b = testFunctionResult->createBenchmark();

    b->setTag(tag);

    b->setRotation(mainWindowRotationAngle());

    b->setListSize(itemCount);

    b->setUseListItemCache(mSubtreeCacheEnabled);

    b->setImageBasedRendering(mMainView->imageBasedRendering());

    b->setTheme(Theme::p()->currentThemeName());

    b->setWidth(mMainView->size().width());

    b->setHeight(mMainView->size().height());

    QGraphicsWidget *tw = mMainView->testWidget();

    ItemRecyclingList *list = dynamic_cast<ItemRecyclingList *>(tw);

    if (list) {

        QString type = list->objectName();

        if(mResMon && mCpuMemLogging) {

            //CPU/MEM begin

            mResMon->BeginMeasureCPULoad(); 

            mResMon->BeginMeasureMemoryLoad();

        }

        QTime t;

        t.start();

        for (int i=0; i<itemCount; ++i)

           delete list->takeItem(0);

        int took = t.elapsed();

        if(mResMon && mCpuMemLogging) {

            //CPU/MEM end

            createCpuBenchmark(testFunctionResult, tag, itemCount, Benchmark::RecyclingListType,Theme::p()->currentThemeName(), mResMon->EndMeasureCPULoad());

            createMemoryBenchmark(testFunctionResult, tag, itemCount, Benchmark::RecyclingListType, Theme::p()->currentThemeName(), mResMon->EndMeasureMemoryLoad());

        }

        b->setValue(took);

        b->setListType(Benchmark::RecyclingListType);

    }

    else {

        SimpleList *list = dynamic_cast<SimpleList*>(tw);

        if (list) {

            QString type = list->objectName();

            if(mResMon && mCpuMemLogging) {

                //CPU/MEM begin

                mResMon->BeginMeasureCPULoad(); 

                mResMon->BeginMeasureMemoryLoad();

            }

            QTime t;

            t.start();

            for (int i=0; i<itemCount; ++i)

                delete list->takeItem(0);

            int took = t.elapsed();

            if(mResMon && mCpuMemLogging) {

                //CPU/MEM end

                createCpuBenchmark(testFunctionResult, tag, itemCount, Benchmark::SimpleListType, Theme::p()->currentThemeName(), mResMon->EndMeasureCPULoad());

                createMemoryBenchmark(testFunctionResult, tag, itemCount, Benchmark::SimpleListType,Theme::p()->currentThemeName(), mResMon->EndMeasureMemoryLoad());

            }

            b->setValue(took);

            b->setListType(Benchmark::SimpleListType);

        }

    }

    QTimer::singleShot(EmitDoneTimeout, this, SLOT(testIsDone()));

}

void TestController::themeChange(int theme, TestFunctionResult *testFunctionResult, const QString &tag)

{

    if (!mMainView) {

        QTimer::singleShot(EmitDoneTimeout, this, SLOT(testIsDone()));

        return;

    }

    QString listName = "";

    int itemCount = 0;

    Benchmark::ListType type = Benchmark::ListTypeNone;

    QGraphicsWidget *tw = mMainView->testWidget();

    ItemRecyclingList *list = dynamic_cast<ItemRecyclingList *>(tw);

    if (list) {

        type = Benchmark::RecyclingListType;

        itemCount = list->indexCount();

    }

    else {

        SimpleList *list = dynamic_cast<SimpleList*>(tw);

        if (list) {

            type = Benchmark::SimpleListType;

            itemCount = list->itemCount();

        }

        else {

            QTimer::singleShot(EmitDoneTimeout, this, SLOT(testIsDone()));

            return;

        }

    }

    Benchmark *b = testFunctionResult->createBenchmark();

    b->setTag(tag);

    b->setTheme(Theme::p()->currentThemeName());

    //CPU/MEM begin

    QString currentTheme = Theme::p()->currentThemeName();

    if(mResMon && mCpuMemLogging) {

        mResMon->BeginMeasureCPULoad(); 

        mResMon->BeginMeasureMemoryLoad();

    }

    QTime t;

    t.start();

    Theme::p()->setTheme(Theme::Themes(theme));

    int took = t.elapsed();

    b->setValue(took);

    b->setRotation(mainWindowRotationAngle());

    b->setListType(type);

    b->setListSize(itemCount);

    b->setUseListItemCache(mSubtreeCacheEnabled);

    b->setImageBasedRendering(mMainView->imageBasedRendering());

    b->setWidth(mMainView->size().width());

    b->setHeight(mMainView->size().height());

    if(mResMon && mCpuMemLogging) {

        //CPU/MEM end

        createCpuBenchmark(testFunctionResult, tag, itemCount, type, currentTheme, mResMon->EndMeasureCPULoad());

        createMemoryBenchmark(testFunctionResult, tag, itemCount, type,currentTheme, mResMon->EndMeasureMemoryLoad());

    }

    QTimer::singleShot(EmitDoneTimeout, this, SLOT(testIsDone()));

}