/*

* 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 "CpWatchDog.h"

#include <qcoreapplication>

#include <qsettings>

#include <qdebug>

#include "cplogger.h"

//const value definition

const int DefaultMaxPluginBlackListedRuns = 5;

const int DefaultWatchdogActivationLimit  = 1;

const int WatchdogActivationDisabled      = -1;

//Key definition for QSettings

const QString KeyWatchDogStatus                   = "WatchDog";

const QString KeyWatchDogCpRunning                = "cprunning";

const QString KeyWatchDogCrashCounter             = "crashcounter";

const QString KeyWatchDogMaxPluginBlackListedRuns = "maxpluginblacklistedruns";

const QString KeyWatchDogActivationLimit          = "activationlimit";

const QString KeyWatchDogQuarantine               = "Quarantine";

const QString KeyWatchDogQuarantineUid            = "uid";

const QString KeyWatchDogBlackList                = "BlackList";

const QString KeyWatchDogBlackListUid             = "uid";

const QString KeyWatchDogBlackListRunsAfterCrash  = "runsaftercrash";

CpWatchDog *CpWatchDog::self = 0;

CpWatchDog::PluginQuarantine::PluginQuarantine()

: mUid(0), mRunsAfterCrash(0)

{

}

void CpWatchDog::PluginQuarantine::read(QSettings &settings)

{

    mUid = settings.value(KeyWatchDogBlackListUid,0).toInt();

    mRunsAfterCrash = settings.value(KeyWatchDogBlackListRunsAfterCrash,0).toInt();

}

void CpWatchDog::PluginQuarantine::store(QSettings &settings)

{

    settings.setValue(KeyWatchDogBlackListUid,mUid);

    settings.setValue(KeyWatchDogBlackListRunsAfterCrash,mRunsAfterCrash);

}

CpWatchDog *CpWatchDog::instance()

{

    if (!self) {

        self = new CpWatchDog;

    }

    return self;

}

CpWatchDog::CpWatchDog()

    : mActive(true),

      mCrashCounter(0),

      mAppRunning(true),

      mMaxPluginBlackListedRuns(DefaultMaxPluginBlackListedRuns),

      mWatchdogActivationLimit(DefaultWatchdogActivationLimit)

{

    //delete watch dog when application is about to quit.

    connect(qApp,SIGNAL(aboutToQuit()),this,SLOT(destroy()));

    init();

}

CpWatchDog::~CpWatchDog()

{

    reportCleanExit();

    updateBlackListedPluginRunCounters();

    storeState();

}

void CpWatchDog::destroy()

{

    delete this;

    self = 0;

}

void CpWatchDog::quarantine(int uid)

{

    if (isActive()) {

        mQuarantine.append(uid);

        storeQuarantine();

    }

}

void CpWatchDog::removeFromQuarantine(int uid)

{

    if (isActive()) {

        int index = mQuarantine.indexOf(uid);

        if (index >= 0) {

            mQuarantine.remove(index);

            storeQuarantine();

        }

    }

}

bool CpWatchDog::isActive() const

{

    return mActive;

}

bool CpWatchDog::wasCleanExit() const

{

    return !mAppRunning;

}

void CpWatchDog::reportCleanExit()

{

    mAppRunning = false;

    QSettings settings;

    settings.beginGroup(KeyWatchDogStatus);

    settings.setValue(KeyWatchDogCpRunning,mAppRunning);

    settings.endGroup();

}

bool CpWatchDog::isInBlackList(int uid)

{

    bool found = false;

    if (isActive()) {

        foreach(const PluginQuarantine &quarantine,mBlackList) {

            if (quarantine.mUid == uid) {

                found = true;

                break;

            }

        }

    }

    if (found) {

        CpLogger() << "Plugin " << QString("0x%1").arg(uid,0,16) << "is in black list." << "\r\n";

    }

    return found;

}

void CpWatchDog::init()

{

    readState();

    if (!wasCleanExit() 

        && mWatchdogActivationLimit != WatchdogActivationDisabled) {

        mCrashCounter++;

        mActive = true;

        for (int i(0); i < mQuarantine.size(); i++) {

            if (!isInBlackList(mQuarantine[i])) {

                PluginQuarantine quarantine;

                quarantine.mUid = mQuarantine[i];

                quarantine.mRunsAfterCrash = 0;

                mBlackList.append(quarantine);

                mQuarantine.remove(i);

                i--;

            }

        }

    }

    else {

        mActive = false;

        mCrashCounter = 0;

        mQuarantine.clear();

    }

    mAppRunning = true;

    storeState();

}

void CpWatchDog::readState()

{

    QSettings settings;

    settings.beginGroup(KeyWatchDogStatus);

    int appRunning = settings.value(KeyWatchDogCpRunning,0).toInt();

    mAppRunning = (appRunning != 0);

    mCrashCounter = settings.value(KeyWatchDogCrashCounter,0).toInt();

    mMaxPluginBlackListedRuns = settings.value(

            KeyWatchDogMaxPluginBlackListedRuns,DefaultMaxPluginBlackListedRuns).toInt();

    mWatchdogActivationLimit = settings.value(

            KeyWatchDogActivationLimit,DefaultWatchdogActivationLimit).toInt();

    settings.endGroup();

    readQuarantine();

    readBlackList();

}

void CpWatchDog::storeState()

{

    {

        QSettings settings;

        settings.beginGroup(KeyWatchDogStatus);

        settings.setValue(KeyWatchDogCpRunning, mAppRunning ? 1 : 0);  

        settings.setValue(KeyWatchDogCrashCounter,mCrashCounter);   

        settings.setValue(KeyWatchDogMaxPluginBlackListedRuns,mMaxPluginBlackListedRuns);

        settings.setValue(KeyWatchDogActivationLimit,mWatchdogActivationLimit);

        settings.endGroup();

    } //Destructor of QSettings: writes any unsaved changes to permanent storage

    storeQuarantine();

    storeBlackList();

}

void CpWatchDog::readQuarantine()

{

    QSettings settings;

    int size = settings.beginReadArray(KeyWatchDogQuarantine);

    for (int i(0); i < size; i++) {

        settings.setArrayIndex(i);

        int uid = settings.value(KeyWatchDogQuarantineUid,0).toInt();

        if (uid != 0) {

            mQuarantine.append(uid);

        }

    }

    settings.endArray();

}

void CpWatchDog::storeQuarantine()

{

    QSettings settings;

    //remove old array data before updating

    settings.beginGroup(KeyWatchDogQuarantine);

    settings.remove(QString());

    settings.endGroup();

    settings.beginWriteArray(KeyWatchDogQuarantine);

    int size = mQuarantine.size();

    for (int i(0); i < size; i++) {

        settings.setArrayIndex(i);

        settings.setValue(KeyWatchDogQuarantineUid,mQuarantine[i]);

    }

    settings.endArray();

}

void CpWatchDog::readBlackList()

{

    QSettings settings;

    int size = settings.beginReadArray(KeyWatchDogBlackList);

    for (int i(0); i < size; i++) {

        settings.setArrayIndex(i);

        PluginQuarantine quarantine;

        quarantine.read(settings);

        if (quarantine.mUid != 0) {

            mBlackList.append(quarantine);

        }

    }

    settings.endArray();

}

void CpWatchDog::storeBlackList()

{

    QSettings settings;

    //remove old array data before updating

    settings.beginGroup(KeyWatchDogBlackList);

    settings.remove(QString());

    settings.endGroup();

    settings.beginWriteArray(KeyWatchDogBlackList);    

    int size = mBlackList.size();

    for (int i(0); i < size; i++) {

        settings.setArrayIndex(i);

        mBlackList[i].store(settings);

    }

    settings.endArray();

}

void CpWatchDog::updateBlackListedPluginRunCounters()

{

    for (int i(0); i < mBlackList.size(); i++) {

        mBlackList[i].mRunsAfterCrash++;

        if (mBlackList[i].mRunsAfterCrash > mMaxPluginBlackListedRuns) {

            mBlackList.remove(i);

            i--;

        }

    }

}