/*

 * 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++ based Class.

 *              Stf Controller implementation.

 *

 */

#include "stfqtuicontroller.h"

#include <stifinternal/UIStoreIf.h>

#include <stifinternal/UIStoreContainer.h>

#include <QDateTime>

const QString TEMPSETNAME = "TEMPSET";

const QString DEFAULTINI = "c:\\testframework\\testframework.ini";

StfQtUIController::StfQtUIController(IStfQtUIModel* aModel) :

    model(aModel), 

    isShowOutput(false), 

    iCurrentRunPos(0),

    isLoopInfinitely(false),

    loopTimes(0)

    {

    executor = new CStifExecutor();

    executor->OpenIniFile(DEFAULTINI);

    executor->AddStifCaseUpdateListener(this);

    }

StfQtUIController::~StfQtUIController()

    {

    executor->RemoveStifCaseUpdateListener(this);

    delete executor;

    executor = NULL;

    }

//for cases

bool StfQtUIController::OpenEngineIniFile(const QString& fileName)

    {

    QString path = fileName;

    if(path.contains('/'))

        {

        path = path.replace('/', '\\');

        }

    executor->RemoveStifCaseUpdateListener(this);

    delete executor;

    executor = new CStifExecutor();

    bool rst = executor->OpenIniFile(path);

    executor->AddStifCaseUpdateListener(this);

    return rst;

    }

QList<QString> StfQtUIController::GetModuleList()

    {

    QList<CSTFModule> modules = executor->GetModuleList();

    QList<QString> moduleList;

    foreach(CSTFModule m, modules)

            {

            moduleList.append(m.Name());

            }

    return moduleList;

    }

CSTFModule StfQtUIController::GetModuleByName(const QString& moduleName)

    {

    QList<CSTFModule> modules = executor->GetModuleList();

    CSTFModule module;

    foreach(CSTFModule m, modules)

        {

        if(m.Name() == moduleName)

            {

            module = m;

            break;

            }

        }

    return module;

    }

QList<QString> StfQtUIController::GetCaseListByModule(const QString& moduleName)

    {

    QList<QString> caseList;

    if (moduleName != "")

        {

        QList<CSTFCase> cases = executor->GetCaseList(moduleName);

        foreach(CSTFCase c, cases)

                {

                caseList.append(c.Name());

                }

        }

    return caseList;

    }

CSTFCase StfQtUIController::GetCase(const QString& moduleName, const int index)

    {

    CSTFCase rst;

    if(moduleName != "")

        {

        QList<CSTFCase> cases = executor->GetCaseList(moduleName);

        if(index < cases.length())

            {

            rst = cases.at(index);

            }

        }

    return rst;

    }

void StfQtUIController::RunCases(const QList<CSTFCase>& caseList,

        const TSTFCaseRunningType& type)

    {

    if (caseList.size() == 1)

        {

        CSTFCase aCase = caseList.at(0);

        QString msg = "Start execute case:" + aCase.Name();

        FireOnGetOutput(msg);

        executor->ExecuteSingleCase(aCase.ModuleName(), aCase.Index());

        }

    else

        {

        //create a temp set, append cases into the set and execute it.

        executor->CreateSet(TEMPSETNAME);

        foreach(CSTFCase aCase, caseList)

                {

                executor->AddtoSet(TEMPSETNAME, aCase);

                }

        RunSets(TEMPSETNAME, type);

        executor->RemoveSet(TEMPSETNAME);

        }

    }

// run cases repeatly. 

// By default, loopTimes = -1 means loop infinitely util user stop it.

void StfQtUIController::RepeatRunCases(const QList<CSTFCase>& aCaseList, const bool aIsLoopInfinitely, const int aLoopTimes)

    {

    InitRepeatSetting(aIsLoopInfinitely, aLoopTimes);

    repeatRunCaseList = aCaseList;

    Execution();

    }

void StfQtUIController::InitRepeatSetting(const bool aIsLoopInfinitely, const int aLoopTimes)

    {

    loopTimes = aLoopTimes;

    isLoopInfinitely = aIsLoopInfinitely;

    iCurrentRunPos = 0;

    }

void StfQtUIController::ResetRepeatSetting()

    {

    iCurrentRunPos = 0;

    isLoopInfinitely = false;

    loopTimes = 0;

    }

// Repeat execution cases

void StfQtUIController::Execution()

    {

    if(loopTimes > 0  || isLoopInfinitely)

        {

        int count = repeatRunCaseList.count();

        CSTFCase aCase = repeatRunCaseList.at(iCurrentRunPos);

        QString msg = "Start execute case:" + aCase.Name();

        FireOnGetOutput(msg);

        executor->ExecuteSingleCase(aCase.ModuleName(), aCase.Index());

        iCurrentRunPos++;

        if( iCurrentRunPos >= count )

            {

            iCurrentRunPos = 0;

            loopTimes --;

            }    

        }

    }

bool StfQtUIController::AddCaseToSet(const QList<CSTFCase>& caseList,

        const QString& setName)

    {

    QString name = setName;

    bool rst = true;

    foreach(CSTFCase aCase, caseList)

            {

            rst = executor->AddtoSet(name, aCase);

            if(!rst)

                {

                break;

                }

            }

    if(!rst)

        {

        return false;

        }

    rst = executor->SaveSet(name);

    FireOnSetListChanged();

    return rst;

    }

//for set

QList<QString> StfQtUIController::GetSetList()

    {

    return executor->GetSetList();

    }

QList<QString> StfQtUIController::GetCaseListBySet(const QString& setName)

    {

    QList<CSTFCase> cases = executor->GetCaseListFromSet(setName);

    QList<QString> caseList;

    foreach(CSTFCase c, cases)

            {

            caseList.append(c.Name());

            }

    return caseList;

    }

bool StfQtUIController::CreateSet(QString& setName)

    {

    bool rst = executor->CreateSet(setName);

    if(!rst)

        {

        return rst;

        }

    rst = executor->SaveSet(setName);

    FireOnSetListChanged();

    return rst;

    }

bool StfQtUIController::DeleteSet(const QString& setName)

    {

    bool rst = executor->RemoveSet(setName);

    if(!rst)

        {

        return false;

        }

    QString name = setName;

    rst = executor->SaveSet(name);

    FireOnSetListChanged();

    return rst;

    }

void StfQtUIController::RunSets(const QString& setName, const TSTFCaseRunningType& type)

    {

    executor->ExecuteSet(setName, 0, type);

    }

//for Started

void StfQtUIController::PauseCase()

    {

    model->PauseCase();

    QString msg = "Execution Paused";

    FireOnGetOutput(msg);

    }

void StfQtUIController::ResumeCase()

    {

    model->ResumeCase();

    FireOnGetOutput("Execution Resumed");

    }

void StfQtUIController::AbortCase()

    {

    model->AbortCase();

    FireOnGetOutput("Case Aborted");

    }

CSTFCase StfQtUIController::GetRunningCase(int index)

    {

    CStartedTestCase* startedCase = (CStartedTestCase*) index;

    return model->GetRunningCase(startedCase);

    }

bool StfQtUIController::ShowOutput()

    {

    return isShowOutput;

    }

void StfQtUIController::SetShowOutput(bool isShow)

    {

    isShowOutput = isShow;

    }

QList<CSTFCase> StfQtUIController::GetCasesByStatus(const TSTFCaseStatusType& type)

    {

    return model->GetCasesByStatus(type);

    }

void StfQtUIController::AddStfEventListener(IStfEventListener* listener)

    {

    if (!listenerList.contains(listener))

        {

        listenerList.append(listener);

        }

    }

void StfQtUIController::RemoveStfEventListener(IStfEventListener* listener)

    {

    if (listenerList.contains(listener))

        {

        listenerList.removeOne(listener);

        }

    }

void StfQtUIController::OnGetCaseUpdated(CStartedTestCase* aCase,

        CSTFCase& stfcase, int flags)

    {

    if (flags & CUIStoreIf::EPrintUpdate || aCase == NULL)

        {

        return;

        }

    QString msg = "case Name:";

    msg += stfcase.Name() + "\r\n Status:";

    flags = aCase->Status();

    if (flags & CUIStoreIf::EStatusRunning)

        {

        model->AddRunningCase(aCase, stfcase);

        msg += "start running";

        FireOnCaseOutputChanged(IStfEventListener::ECreate, (int) aCase,

                stfcase.Name());

        }

    else if (flags & CUIStoreIf::EStatusAborted)

        {

        FireOnCaseOutputChanged(IStfEventListener::EClose, (int) aCase, "");

        model->RemoveRunningCase(aCase);

        model->AddCaseByStatus(EStatusAborted, stfcase);

        msg += "aborted";

        //reset repeat execution information

        ResetRepeatSetting();

        }

    else if (flags & CUIStoreIf::EStatusExecuted)

        {

        FireOnCaseOutputChanged(IStfEventListener::EClose, (int) aCase, "");

        model->RemoveRunningCase(aCase);

        model->AddCaseByStatus(EStatusExecuted, stfcase);

        if (flags & CUIStoreIf::EStatusCrashed)

            {

            model->AddCaseByStatus(EStatusCrashed, stfcase);

            msg += "crashed";

            }

        else if (flags & CUIStoreIf::EStatusFailed)

            {

            model->AddCaseByStatus(EStatusFailed, stfcase);

            msg += "failed";

            }

        else if (flags & CUIStoreIf::EStatusPassed)

            {

            model->AddCaseByStatus(EStatusPassed, stfcase);

            msg += "passed";

            }

        // if repeat execution is choosed, start to execution again.

        if(loopTimes > 0 || isLoopInfinitely)

            {

            Execution();

            }

        }

    else

        {

        return;

        }

    FireOnGetOutput(msg);

    }

void StfQtUIController::OnGetCaseOutput(CStartedTestCase* aCase, QString& msg)

    {

    FireOnCaseOutputChanged(IStfEventListener::EOutput, (int) aCase, msg);

    }

void StfQtUIController::FireOnCaseOutputChanged(

        IStfEventListener::CaseOutputCommand cmd, int index, QString msg)

    {

    if (true)//ShowOutput

        {

        foreach(IStfEventListener* listener, listenerList)

                {

                listener->OnCaseOutputChanged(cmd,

                        QString::number(index, 10), msg);

                }

        }

    }

void StfQtUIController::FireOnGetOutput(QString message)

    {

    foreach(IStfEventListener* listener, listenerList)

            {

            listener->OnGetMessage(message);

            }

    }

void StfQtUIController::FireOnSetListChanged()

    {

    foreach(IStfEventListener* listener, listenerList)

            {

            listener->OnSetListChanged();

            }

    }