/*
* ============================================================================
*  Name        : hbindicatorautolockplugin.cpp
*  Part of     : hb / hbcore
*  Description : indicator autolock plugin implementation
*  Version     : %version: 1 %
*
*  Copyright (c) 2009 Nokia.  All rights reserved.
*  This material, including documentation and any related computer
*  programs, is protected by copyright controlled by Nokia.  All
*  rights are reserved.  Copying, including reproducing, storing,
*  adapting or translating, any or all of this material requires the
*  prior written consent of Nokia.  This material also contains
*  confidential information which may not be disclosed to others
*  without the prior written consent of Nokia.
* ============================================================================
*/

#include <QtPlugin>
#include <QVariant>
#include <HbInstance>
#include <HbMainWindow>
#include <QDebug>

#include "hbindicatorautolockplugin.h"

Q_EXPORT_PLUGIN(HbIndicatorAutolockPlugin)

// Constructor
HbIndicatorAutolockPlugin::HbIndicatorAutolockPlugin() : mError(0)
{
    for (int i = 0; i < IndicatorCount; ++i) {
        mIndicatorTypes.append(indicatorName(i));
    }
}

// Destructor
HbIndicatorAutolockPlugin::~HbIndicatorAutolockPlugin()
{
}

// Return notification types this plugin implements
QStringList HbIndicatorAutolockPlugin::indicatorTypes() const
{
    return mIndicatorTypes;
}

// Check if client is allowed to use notification widget
bool HbIndicatorAutolockPlugin::accessAllowed(const QString &indicatorType,
    const QVariantMap &securityInfo) const
{
    Q_UNUSED(indicatorType)
    Q_UNUSED(securityInfo)

    // This plugin doesn't perform operations that may compromise security.
    // All clients are allowed to use.
    return true;
}

HbIndicatorInterface* HbIndicatorAutolockPlugin::createIndicator(
        const QString &indicatorType)
{
    HbIndicatorInterface *indicator = 0;
    int index(typeIndex(indicatorType));
    if (index >= 0) {
        indicator = new HbAutolockIndicator(
                indicatorType, index, IndicatorInfos[index].interaction);
    }
    return indicator;
}

int HbIndicatorAutolockPlugin::error() const
{
    return mError;
}

int HbIndicatorAutolockPlugin::typeIndex(const QString &indicatorType) const
{
    for (int i = 0; i < mIndicatorTypes.count(); ++i) {
        if (mIndicatorTypes.at(i) == indicatorType) {
            return i;
        }
    }
    return -1;
}

HbAutolockIndicator::HbAutolockIndicator(const QString &indicatorType,
                                 int typeIndex,
                                 Interaction interaction) :
    HbIndicatorInterface(indicatorType, IndicatorInfos[typeIndex].category,
    (interaction == InteractionNone) ? NoInteraction : InteractionActivated),
    mPrimaryText(IndicatorInfos[typeIndex].primaryText),
    mSecondaryText(IndicatorInfos[typeIndex].secondaryText),
    mIcon(IndicatorInfos[typeIndex].icon),
    mIconMono(IndicatorInfos[typeIndex].iconMono),
    mTypeIndex(typeIndex), mInteraction(interaction)
{
}

HbAutolockIndicator::~HbAutolockIndicator()
{
}

bool HbAutolockIndicator::handleInteraction(InteractionType type)
{
    if (type == InteractionActivated) {
        switch(mInteraction) {
        case ChangeContent:
            mPrimaryText = "Clicked";
            mSecondaryText = "content changed!";
            mIcon = "qtg_mono_ok.svg";
            break;
        case Deactivate:
            emit deactivate();
            break;
        case ChangeOrientation:
        		qDebug() << "============= HbAutolockIndicator::handleInteraction doesn't react to ChangeOrientation";
            /*
            if (hbInstance->orientation() == Qt::Horizontal) {
                hbInstance->setOrientation(Qt::Vertical);
            } else {
                hbInstance->setOrientation(Qt::Horizontal);
            }
            */
            if (hbInstance->allMainWindows().at(0)->orientation() == Qt::Horizontal) {
                hbInstance->allMainWindows().at(0)->setOrientation(Qt::Vertical);
            } else {
                hbInstance->allMainWindows().at(0)->setOrientation(Qt::Horizontal);
            }
            break;
        default:
            return false;
        }
        emit dataChanged();
    }
    return false;
}

QVariant HbAutolockIndicator::indicatorData(int role) const
{
    if (role == PrimaryTextRole) {
        if (mParameter.isValid()) {
        		qDebug() << "============= HbAutolockIndicator::indicatorData 11=";
						qDebug() << QString("data:").append(mParameter.toString())
                                   .append(" ")
                                   .append(mPrimaryText);
            return QString("data:").append(mParameter.toString())
                                   .append(" ")
                                   .append(mPrimaryText);
        } else {
        		qDebug() << "============= HbAutolockIndicator::indicatorData 12=";
        		qDebug() << mPrimaryText ;
            return mPrimaryText;
        }
    } else if (role == SecondaryTextRole && mTypeIndex != 7) {
        if (mParameter.isValid()) {
        		qDebug() << "============= HbAutolockIndicator::indicatorData 21=";
						qDebug() << QString("data:").append(mParameter.toString())
                                   .append(" ")
                                   .append(mPrimaryText);
            return QString("data:").append(mParameter.toString())
                                   .append(" ")
                                   .append(mSecondaryText);
        } else {
        		qDebug() << "============= HbAutolockIndicator::indicatorData 22=";
        		qDebug() << mSecondaryText ;
            return mSecondaryText;
        }
    } else if (role == MonoDecorationNameRole) {
        if (mParameter.isValid()) {
        		qDebug() << "============= HbAutolockIndicator::indicatorData 31=";
        		qDebug() << "qtg_mono_ok.svg" ;
            return "qtg_mono_ok.svg";
        } else {
        		qDebug() << "============= HbAutolockIndicator::indicatorData 32=";
        		qDebug() << mIcon ;
            return mIcon;
        }
    } else if (role == DecorationNameRole) {
        if (mParameter.isValid()) {
        		qDebug() << "============= HbAutolockIndicator::indicatorData 41=";
        		qDebug() << "qtg_mono_ok.svg" ;
            return "qtg_mono_ok.svg";
        } else {
        		qDebug() << "============= HbAutolockIndicator::indicatorData 42=";
        		qDebug() << mIcon ;
            return mIcon;
        }
    } else if (role == MonoDecorationNameRole) {
        if (mParameter.isValid()) {
        		qDebug() << "============= HbAutolockIndicator::indicatorData 51=";
        		qDebug() << "qtg_mono_ok.svg" ;
            return "qtg_mono_ok.svg";
        } else {
        		qDebug() << "============= HbAutolockIndicator::indicatorData 52=";
        		qDebug() << mIconMono ;
            return mIconMono;
        }
    }
    return QVariant();
}

bool HbAutolockIndicator::handleClientRequest(RequestType type, const QVariant &parameter)
{
    bool handled(false);
    switch (type) {
    case RequestActivate:
        if (mParameter != parameter) {
            mParameter = parameter;
            emit dataChanged();
        }
        handled =  true;
        break;
    default:
        mParameter.clear();
    }

    return handled;
}