/*

 * 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: QT C++ and Symbian C++ combination Class.

 *              STIF UI interface and engine caller implementaion.

 *

 */

#include <e32base.h>

#include <e32cons.h>

#include <e32svr.h>

#include <f32file.h>

#include <HAL.h>

#include <hal_data.h>

#include <QString>

#include "stifexecutor.h"

#include "StifTFwIf.h"

CStifExecutor::CStifExecutor() :

    listenerList(NULL)

    {

    TInt result;

    TRAP(result, CUIStoreIf::ConstructL());

    if (result != KErrNone)

        {

        return;

        }

    TRAP(result, iBuffer = HBufC::NewL(500));

    }

CStifExecutor::~CStifExecutor()

    {

    UIStore().Close();

    delete iBuffer;

    if (listenerList)

        {

        delete listenerList;

        listenerList = NULL;

        }

    }

bool CStifExecutor::OpenIniFile(const QString& filename)

    {

    TInt result = UIStore().Open(QString2TPtrC(filename));

    return (result == KErrNone);

    }

TPtrC CStifExecutor::QString2TPtrC(const QString& aString)

    {

    TPtrC ret(reinterpret_cast<const TText*> (aString.constData()),

            aString.length());

    return ret;

    }

QString CStifExecutor::TDesC2QString(const TDesC& des)

    {

    //#ifdef QT_NO_UNICODE

    //return QString::fromLocal8Bit((char*)des.Ptr(), des.Length());

    //#else

    QString rst = QString::fromUtf16(des.Ptr(), des.Length());

    return rst;

    //#endif

    }

void CStifExecutor::AddStifCaseUpdateListener(

        IStifCaseUpdateListener* listener)

    {

    if (!listenerList)

        {

        listenerList = new QList<IStifCaseUpdateListener*> ();

        }

    if (!listenerList->contains(listener))

        {

        listenerList->append(listener);

        }

    }

void CStifExecutor::RemoveStifCaseUpdateListener(

        IStifCaseUpdateListener* listener)

    {

    if (!listenerList)

        {

        return;

        }

    if (listenerList->contains(listener))

        {

        listenerList->removeOne(listener);

        }

    }

QList<CSTFModule> CStifExecutor::GetModuleList()

    {

    QList<CSTFModule> list;

    RRefArray<TDesC> modules;

    TInt ret = UIStore().Modules(modules);

    for (TInt i = 0; i < modules.Count(); i++)

        {

        CSTFModule module;

        module.SetName(QString::fromUtf16(modules[i].Ptr(),

                modules[i].Length()));

        //module.SetName(TDesC2QString(modules[i]));

        list.append(module);

        }

    modules.Reset();

    modules.Close();

    return list;

    }

QList<CSTFCase> CStifExecutor::GetCaseList(const QString& moduleName)

    {

    TPtrC name = QString2TPtrC(moduleName);

    QList<CSTFCase> list;

    RRefArray<CTestInfo> testCases;

    TInt ret = UIStore().TestCases(testCases, name, KNullDesC);

    for (TInt i = 0; i < testCases.Count(); i++)

        {

        CSTFCase testcase;

        testcase.SetName(TDesC2QString(testCases[i].TestCaseTitle()));

        testcase.SetIndex(i);

        list.append(testcase);

        }

    testCases.Reset();

    testCases.Close();

    return list;

    }

void CStifExecutor::ExecuteSingleCase(const QString& moduleName, const int caseIndex)

    {

    TPtrC name = QString2TPtrC(moduleName);

    RRefArray<CTestInfo> testCases;

    TInt ret = UIStore().TestCases(testCases, name, KNullDesC);

    if (testCases.Count() > caseIndex)

        {

        TInt index;

        UIStore().StartTestCase(testCases[caseIndex], index);

        }

    testCases.Reset();

    testCases.Close();

    }

QList<QString> CStifExecutor::GetSetList()

    {

    QList<QString> list;

    RRefArray<TDesC> aArray;

    TInt ret = UIStore().GetTestSetsList(aArray);

    if (ret != KErrNone) //setInfos.Count() != 1

        {

        return list;

        }

    for (int i = 0; i < aArray.Count(); i++)

        {

        list.append(TDesC2QString(aArray[i]));

        }

    aArray.Reset();

    aArray.Close();

    return list;

    }

QList<CSTFCase> CStifExecutor::GetCaseListFromSet(const QString& setName)

    {

    QList<CSTFCase> list;

    TPtrC name = QString2TPtrC(setName);

    if (name.Length() == 0)

        {

        return list;

        }

    TInt ret = UIStore().LoadTestSet(name);

    const CTestSetInfo* set = NULL;

    TRAP(ret , set = &UIStore().TestSetL(name));

    if(ret != KErrNone)

        {

        return list;

        }

    const RRefArray<const CTestInfo>& testCases = set->TestCases();

    TInt count = testCases.Count();

    for (TInt i = 0; i < count; i++)

        {

        CSTFCase testcase;

        testcase.SetName(TDesC2QString(testCases[i].TestCaseTitle()));

        testcase.SetIndex(testCases[i].TestCaseNum());

        testcase.SetModuleName(TDesC2QString(testCases[i].ModuleName()));

        list.append(testcase);

        }

    return list;

    }

    {

    TPtrC name = QString2TPtrC(setName);

    TInt ret = UIStore().CreateTestSet(name);

    }

    {

    TPtrC name = QString2TPtrC(setName);

    TFileName testSetName;

    testSetName.Copy(name);

    setName = TDesC2QString(testSetName);

    }

    {

    //This method wil not work at this stage.

    TPtrC name = QString2TPtrC(setName);

    }

    {

    //IMPORT_C TInt AddToTestSet( const TDesC& aSetName, const CTestInfo& aTestInfo );

    TPtrC modulename = QString2TPtrC(caseInfo.ModuleName());

    RRefArray<CTestInfo> testCases;

    TInt ret = UIStore().TestCases(testCases, modulename, KNullDesC);

    for (TInt i = 0; i < testCases.Count(); i++)

        {

            {

            ret = UIStore().AddToTestSet(QString2TPtrC(setName), testCases[i]);

            break;

            }

        }

    testCases.Reset();

    testCases.Close();

    }

void CStifExecutor::ExecuteSet(const QString& SetName, const int startIndex,

        const TSTFCaseRunningType type)

    {

    CStartedTestSet::TSetType setType = CStartedTestSet::ESetSequential;

    if (type == Parallel)

        {

        setType = CStartedTestSet::ESetParallel;

        }

    const CTestSetInfo* set = NULL;

    TInt ret;

    TBuf<30> test;

    test.Append(QString2TPtrC(SetName));

    TRAP(ret, set = &UIStore().TestSetL(test));

    //const CTestSetInfo& set = UIStore().TestSetL(QString2TPtrC(SetName));

    if(ret != KErrNone)

        {

        return;

        }

    int a = startIndex;

    ret = UIStore().StartTestSet(*set, a, setType);

    }

void CStifExecutor::Update(CStartedTestCase* aCase, int flags)

    {

    if(aCase == NULL)

        {

        return;

        }

    if (flags & CUIStoreIf::EPrintUpdate)

        {

        //Cases output information update.

        const RPointerArray<CTestProgress> printArray = aCase->PrintArray();

        TInt rows = aCase->PrintArray().Count();

        TPtr buffer(iBuffer->Des());

        buffer.Zero();

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

            {

            buffer.Append(_L("\r\n"));

            buffer.Append(printArray[i]->iDescription);

            buffer.Append(_L(" "));

            buffer.Append(printArray[i]->iText);

            buffer.Append(_L("\r\n"));

            }

        QString msg = TDesC2QString(buffer);

        if (listenerList)

            {

            for (int i = 0; i < listenerList->size(); i++)

                {

                listenerList->at(i)->OnGetCaseOutput(aCase, msg);

                }

            }

        }

    else

        {

        //case status changed update.

        CSTFCase testcase;

        testcase.SetName(TDesC2QString(aCase->TestInfo().TestCaseTitle()));

        testcase.SetIndex(aCase->TestInfo().TestCaseNum());

        testcase.SetModuleName(TDesC2QString(aCase->TestInfo().ModuleName()));

        if (listenerList)

            {

            for (int i = 0; i < listenerList->size(); i++)

                {

                listenerList->at(i)->OnGetCaseUpdated(aCase, testcase, flags);

                }

            }

        }

    }